From Coq Require Import ssreflect ssrfun ssrbool.

From Ltac2 Require Import Ltac2.

From Coq Require Import Ensembles Bool String.

From Coq.Logic Require Import FunctionalExtensionality Eqdep_dec.
From Equations Require Import Equations.

Require Import Coq.Program.Tactics.

From MatchingLogic Require Import Syntax DerivedOperators_Syntax ProofSystem IndexManipulation wftactics.

From stdpp Require Import list tactics fin_sets coGset gmap sets.
New coercion path [Is_true] : bool >-> Sortclass is ambiguous with existing 
[is_true] : bool >-> Sortclass.
[ambiguous-paths,typechecker]
New coercion path [Is_true] : bool >-> Sortclass is ambiguous with existing 
[is_true] : bool >-> Sortclass.
[ambiguous-paths,typechecker]
New coercion path [Is_true] : bool >-> Sortclass is ambiguous with existing 
[is_true] : bool >-> Sortclass.
[ambiguous-paths,typechecker]
New coercion path [Is_true] : bool >-> Sortclass is ambiguous with existing 
[is_true] : bool >-> Sortclass.
[ambiguous-paths,typechecker]
New coercion path [Is_true] : bool >-> Sortclass is ambiguous with existing 
[is_true] : bool >-> Sortclass.
[ambiguous-paths,typechecker]
New coercion path [Is_true] : bool >-> Sortclass is ambiguous with existing 
[is_true] : bool >-> Sortclass.
[ambiguous-paths,typechecker]

From MatchingLogic.Utils Require Import stdpp_ext.
Import extralibrary.
From MatchingLogic Require Import Logic
  ProofInfo
  ProofMode_base 
  ProofMode_propositional
  ProofMode_firstorder
  ProofMode_fixpoint
  ProofMode_reshaper
  BasicProofSystemLemmas
.

Import MatchingLogic.Logic.Notations.

Set Default Proof Mode "Classic".

Open Scope ml_scope.
Open Scope string_scope.
Open Scope list_scope.


Ltac2 _callCompletedTransformedAndCast
  (t : constr) (transform : constr) (tac : constr -> unit) :=
  let tac' := (fun (t' : constr) =>
    let tac'' := (fun (t'' : constr) =>
      let tcast := open_constr:(@useGenericReasoning'' _ _ _ _ _ $t'') in
      fillWithUnderscoresAndCall tac tcast []
    ) in
    fillWithUnderscoresAndCall (fun t''' => tac'' t''') transform [t']
  ) in
  fillWithUnderscoresAndCall tac' t []
.

Ltac2 mlApplyMetaGeneralized (t : constr) :=
  _callCompletedTransformedAndCast t constr:(@reshape_lhs_imp_to_and_forward) _mlApplyMetaRaw ;
  try_solve_pile_basic ();
  try_wfa ()
.

Ltac _mlApplyMetaGeneralized t :=
  _ensureProofMode;
  let ff := ltac2:(t' |- mlApplyMetaGeneralized (Option.get (Ltac1.to_constr(t')))) in
  ff t;
  rewrite [foldr patt_and _ _]/=
.

Tactic Notation "mlApplyMeta" constr(t) :=
  (mlApplyMeta t) || (_mlApplyMetaGeneralized t)
.

#[local]
Example ex_mlApplyMetaGeneralized  {Σ : Signature} Γ a b c d e f:
  well_formed a ->
  well_formed b ->
  well_formed c ->
  well_formed d ->
  well_formed e ->
  well_formed f ->
  Γ ⊢ a ---> b ---> c ---> d ---> e ---> f ->
  Γ ⊢ (a and (b and (c and (d and e)))) ---> f.
Σ: Signature
Γ: Theory
a, b, c, d, e, f: Pattern
well_formed a
→ well_formed b
  → well_formed c
    → well_formed d
      → well_formed e
        → well_formed f
          → Γ ⊢ a ---> b ---> c ---> d ---> e ---> f
            → Γ
              ⊢ a and (b and (c and (d and e))) ---> f
Proof.
Σ: Signature
Γ: Theory
a, b, c, d, e, f: Pattern
well_formed a
→ well_formed b
  → well_formed c
    → well_formed d
      → well_formed e
        → well_formed f
          → Γ ⊢ a ---> b ---> c ---> d ---> e ---> f
            → Γ
              ⊢ a and (b and (c and (d and e))) ---> f
  intros wfa wfb wfc wfd wfe wff H.
Σ: Signature
Γ: Theory
a, b, c, d, e, f: Pattern
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
wfd: well_formed d
wfe: well_formed e
wff: well_formed f
H: Γ ⊢ a ---> b ---> c ---> d ---> e ---> f
Γ ⊢ a and (b and (c and (d and e))) ---> f
  toMLGoal.
Σ: Signature
Γ: Theory
a, b, c, d, e, f: Pattern
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
wfd: well_formed d
wfe: well_formed e
wff: well_formed f
H: Γ ⊢ a ---> b ---> c ---> d ---> e ---> f
well_formed (a and (b and (c and (d and e))) ---> f)
Σ: Signature
Γ: Theory
a, b, c, d, e, f: Pattern
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
wfd: well_formed d
wfe: well_formed e
wff: well_formed f
H: Γ ⊢ a ---> b ---> c ---> d ---> e ---> f
Γ Ⱶ
 a and (b and (c and (d and e))) ---> f

  {
Σ: Signature
Γ: Theory
a, b, c, d, e, f: Pattern
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
wfd: well_formed d
wfe: well_formed e
wff: well_formed f
H: Γ ⊢ a ---> b ---> c ---> d ---> e ---> f
well_formed (a and (b and (c and (d and e))) ---> f) wf_auto2. }
Σ: Signature
Γ: Theory
a, b, c, d, e, f: Pattern
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
wfd: well_formed d
wfe: well_formed e
wff: well_formed f
H: Γ ⊢ a ---> b ---> c ---> d ---> e ---> f
Γ Ⱶ
 a and (b and (c and (d and e))) ---> f

  mlIntro "H1".
Σ: Signature
Γ: Theory
a, b, c, d, e, f: Pattern
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
wfd: well_formed d
wfe: well_formed e
wff: well_formed f
H: Γ ⊢ a ---> b ---> c ---> d ---> e ---> f
Γ Ⱶ
"H1" ∶ a and (b and (c and (d and e))),
--------------------------------------
f

  mlApplyMeta H.
Σ: Signature
Γ: Theory
a, b, c, d, e, f: Pattern
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
wfd: well_formed d
wfe: well_formed e
wff: well_formed f
H: Γ ⊢ a ---> b ---> c ---> d ---> e ---> f
Γ Ⱶ
"H1" ∶ a and (b and (c and (d and e))),
--------------------------------------
a and (b and (c and (d and e)))

  mlExact "H1".
Defined.

Lemma foldr_andb_init_true i l:
  foldr andb i l = true -> i = true.
i: bool
l: list bool
foldr andb i l = true → i = true
Proof.
i: bool
l: list bool
foldr andb i l = true → i = true
  move: i.
l: list bool
∀ i : bool, foldr andb i l = true → i = true
  induction l; cbn; intros i H.
i: bool
H: i = true
i = true
a: bool
l: list bool
IHl: ∀ i : bool, foldr andb i l = true → i = true
i: bool
H: a && foldr andb i l = true
i = true
  {
i: bool
H: i = true
i = true assumption. }
a: bool
l: list bool
IHl: ∀ i : bool, foldr andb i l = true → i = true
i: bool
H: a && foldr andb i l = true
i = true
  {
a: bool
l: list bool
IHl: ∀ i : bool, foldr andb i l = true → i = true
i: bool
H: a && foldr andb i l = true
i = true
    rewrite andb_true_iff in H.
a: bool
l: list bool
IHl: ∀ i : bool, foldr andb i l = true → i = true
i: bool
H: a = true ∧ foldr andb i l = true
i = true
    destruct H as [H1 H2].
a: bool
l: list bool
IHl: ∀ i : bool, foldr andb i l = true → i = true
i: bool
H1: a = true
H2: foldr andb i l = true
i = true
    apply IHl.
a: bool
l: list bool
IHl: ∀ i : bool, foldr andb i l = true → i = true
i: bool
H1: a = true
H2: foldr andb i l = true
foldr andb i l = true
    exact H2.
  }
Qed.

Lemma foldr_andb_true_iff i l:
  foldr andb i l = i && foldr andb true l.
i: bool
l: list bool
foldr andb i l = i && foldr andb true l
Proof.
i: bool
l: list bool
foldr andb i l = i && foldr andb true l
  move: i.
l: list bool
∀ i : bool, foldr andb i l = i && foldr andb true l
  induction l; cbn; intros i.
i: bool
i = i && true
a: bool
l: list bool
IHl: ∀ i : bool, foldr andb i l = i && foldr andb true l
i: bool
a && foldr andb i l = [&& i, a & foldr andb true l]
  {
i: bool
i = i && true
    rewrite andb_true_r.
i: bool
i = i reflexivity.
  }
a: bool
l: list bool
IHl: ∀ i : bool, foldr andb i l = i && foldr andb true l
i: bool
a && foldr andb i l = [&& i, a & foldr andb true l]
  {
a: bool
l: list bool
IHl: ∀ i : bool, foldr andb i l = i && foldr andb true l
i: bool
a && foldr andb i l = [&& i, a & foldr andb true l]
    rewrite IHl.
a: bool
l: list bool
IHl: ∀ i : bool, foldr andb i l = i && foldr andb true l
i: bool
[&& a, i & foldr andb true l] =
[&& i, a & foldr andb true l]
    rewrite !andb_assoc.
a: bool
l: list bool
IHl: ∀ i : bool, foldr andb i l = i && foldr andb true l
i: bool
a && i && foldr andb true l =
i && a && foldr andb true l
    rewrite [a && i]andb_comm.
a: bool
l: list bool
IHl: ∀ i : bool, foldr andb i l = i && foldr andb true l
i: bool
i && a && foldr andb true l =
i && a && foldr andb true l
    reflexivity.
  }
Qed.


Lemma MLGoal_weakenConclusionGen' {Σ : Signature} Γ l₁ l₂ name g' i
    (x : Pattern) (xs : list Pattern)
  :
  forall (r : ImpReshapeS g' (x::xs)),
  mkMLGoal Σ Γ (l₁ ++ (mkNH _ name ((untagPattern (irs_flattened _ _ r)))) :: l₂) ((foldr (patt_and) x xs)) i ->
  mkMLGoal Σ Γ (l₁ ++ (mkNH _ name ((untagPattern (irs_flattened _ _ r)))) :: l₂) g' i.
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
∀ r : ImpReshapeS g' (x :: xs),
  Γ Ⱶ
  l₁ ++ (name ∶ r) :: l₂--------------------------------------
  foldr patt_and x xs
  using i
  
  → Γ Ⱶ
  l₁ ++ (name ∶ r) :: l₂--------------------------------------
  g'
  using i
  
Proof.
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
∀ r : ImpReshapeS g' (x :: xs),
  Γ Ⱶ
  l₁ ++ (name ∶ r) :: l₂--------------------------------------
  foldr patt_and x xs
  using i
  
  → Γ Ⱶ
  l₁ ++ (name ∶ r) :: l₂--------------------------------------
  g'
  using i
  
  intros r H.
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
H: Γ Ⱶ
l₁ ++ (name ∶ r) :: l₂--------------------------------------
foldr patt_and x xs
using i

Γ Ⱶ
l₁ ++ (name ∶ r) :: l₂--------------------------------------
g'
using i

  intros Hwf1 Hwf2.
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
H: Γ Ⱶ
l₁ ++ (name ∶ r) :: l₂--------------------------------------
foldr patt_and x xs
using i

Hwf1: well_formed
  (mlConclusion
     (Γ Ⱶ
      l₁ ++ (name ∶ r) :: l₂--------------------------------------
      g'
      using i
      ))
Hwf2: wf
  (patterns_of
     (mlHypotheses
        (Γ Ⱶ
         l₁ ++ (name ∶ r) :: l₂--------------------------------------
         g'
         using i
         )))
mlTheory
  (Γ Ⱶ
   l₁ ++ (name ∶ r) :: l₂--------------------------------------
   g'
   using i
   )
⊢i foldr patt_imp
     (mlConclusion
        (Γ Ⱶ
         l₁ ++ (name ∶ r) :: l₂--------------------------------------
         g'
         using i
         ))
     (patterns_of
        (mlHypotheses
           (Γ Ⱶ
            l₁ ++ (name ∶ r) :: l₂--------------------------------------
            g'
            using i
            )))
using mlInfo
        (Γ Ⱶ
         l₁ ++ (name ∶ r) :: l₂--------------------------------------
         g'
         using i
         ) cbn in *.
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
H: Γ Ⱶ
l₁ ++ (name ∶ r) :: l₂--------------------------------------
foldr patt_and x xs
using i

Hwf1: well_formed g'
Hwf2: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
Γ
⊢i foldr patt_imp g'
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)) using i

  assert (wfr : well_formed r).
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
H: Γ Ⱶ
l₁ ++ (name ∶ r) :: l₂--------------------------------------
foldr patt_and x xs
using i

Hwf1: well_formed g'
Hwf2: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
well_formed r
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
H: Γ Ⱶ
l₁ ++ (name ∶ r) :: l₂--------------------------------------
foldr patt_and x xs
using i

Hwf1: well_formed g'
Hwf2: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wfr: well_formed r
Γ
⊢i foldr patt_imp g'
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)) using i
  {
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
H: Γ Ⱶ
l₁ ++ (name ∶ r) :: l₂--------------------------------------
foldr patt_and x xs
using i

Hwf1: well_formed g'
Hwf2: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
well_formed r
    clear H.
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
Hwf1: well_formed g'
Hwf2: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
well_formed r
    destruct r as [f pf].
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
f: TaggedPattern
pf: f = foldr patt_imp g' (x :: xs)
Hwf1: well_formed g'
Hwf2: foldr andb true
  (map well_formed
     (map nh_patt
        (l₁ ++
         (name ∶ {|
                   irs_flattened := f;
                   irs_pf := pf
                 |}) :: l₂)))
well_formed {| irs_flattened := f; irs_pf := pf |}
    rewrite pf.
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
f: TaggedPattern
pf: f = foldr patt_imp g' (x :: xs)
Hwf1: well_formed g'
Hwf2: foldr andb true
  (map well_formed
     (map nh_patt
        (l₁ ++
         (name ∶ {|
                   irs_flattened := f;
                   irs_pf := pf
                 |}) :: l₂)))
well_formed (foldr patt_imp g' (x :: xs))
    rewrite pf in Hwf2.
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
f: TaggedPattern
pf: f = foldr patt_imp g' (x :: xs)
Hwf1: well_formed g'
Hwf2: foldr andb true
  (map well_formed
     (map nh_patt
        (l₁ ++
         (name ∶ foldr patt_imp g' (x :: xs))
         :: l₂)))
well_formed (foldr patt_imp g' (x :: xs))
    rewrite 2!map_app in Hwf2.
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
f: TaggedPattern
pf: f = foldr patt_imp g' (x :: xs)
Hwf1: well_formed g'
Hwf2: foldr andb true
  (map well_formed (map nh_patt l₁) ++
   map well_formed
     (map nh_patt
        ((name ∶ foldr patt_imp g' (x :: xs))
         :: l₂)))
well_formed (foldr patt_imp g' (x :: xs))
    rewrite foldr_app in Hwf2.
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
f: TaggedPattern
pf: f = foldr patt_imp g' (x :: xs)
Hwf1: well_formed g'
Hwf2: foldr andb
  (foldr andb true
     (map well_formed
        (map nh_patt
           ((name ∶ foldr patt_imp g' (x :: xs))
            :: l₂))))
  (map well_formed (map nh_patt l₁))
well_formed (foldr patt_imp g' (x :: xs))
    cbn in Hwf2.
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
f: TaggedPattern
pf: f = foldr patt_imp g' (x :: xs)
Hwf1: well_formed g'
Hwf2: foldr andb
  (well_formed (x ---> foldr patt_imp g' xs) &&
   foldr andb true
     (map well_formed (map nh_patt l₂)))
  (map well_formed (map nh_patt l₁))
well_formed (foldr patt_imp g' (x :: xs))
    apply foldr_andb_init_true in Hwf2.
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
f: TaggedPattern
pf: f = foldr patt_imp g' (x :: xs)
Hwf1: well_formed g'
Hwf2: well_formed (x ---> foldr patt_imp g' xs) &&
foldr andb true
  (map well_formed (map nh_patt l₂)) = true
well_formed (foldr patt_imp g' (x :: xs))
    wf_auto2.
  }
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
H: Γ Ⱶ
l₁ ++ (name ∶ r) :: l₂--------------------------------------
foldr patt_and x xs
using i

Hwf1: well_formed g'
Hwf2: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wfr: well_formed r
Γ
⊢i foldr patt_imp g'
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)) using i

 
  assert (wffa: foldr andb true (map well_formed (map nh_patt (l₁ ++ (mkNH _ name r) :: l₂)))).
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
H: Γ Ⱶ
l₁ ++ (name ∶ r) :: l₂--------------------------------------
foldr patt_and x xs
using i

Hwf1: well_formed g'
Hwf2: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wfr: well_formed r
foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
H: Γ Ⱶ
l₁ ++ (name ∶ r) :: l₂--------------------------------------
foldr patt_and x xs
using i

Hwf1: well_formed g'
Hwf2: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wfr: well_formed r
wffa: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
Γ
⊢i foldr patt_imp g'
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)) using i
  {
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
H: Γ Ⱶ
l₁ ++ (name ∶ r) :: l₂--------------------------------------
foldr patt_and x xs
using i

Hwf1: well_formed g'
Hwf2: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wfr: well_formed r
foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
    cbn.
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
H: Γ Ⱶ
l₁ ++ (name ∶ r) :: l₂--------------------------------------
foldr patt_and x xs
using i

Hwf1: well_formed g'
Hwf2: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wfr: well_formed r
foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
    destruct r as [f pf].
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
f: TaggedPattern
pf: f = foldr patt_imp g' (x :: xs)
H: Γ Ⱶ
l₁ ++
(name ∶ {| irs_flattened := f; irs_pf := pf |})
:: l₂--------------------------------------
foldr patt_and x xs
using i

Hwf1: well_formed g'
Hwf2: foldr andb true
  (map well_formed
     (map nh_patt
        (l₁ ++
         (name ∶ {|
                   irs_flattened := f;
                   irs_pf := pf
                 |}) :: l₂)))
wfr: well_formed
  {| irs_flattened := f; irs_pf := pf |}
foldr andb true
  (map well_formed
     (map nh_patt
        (l₁ ++
         (name ∶ {|
                   irs_flattened := f; irs_pf := pf
                 |}) :: l₂)))
    rewrite pf in Hwf2.
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
f: TaggedPattern
pf: f = foldr patt_imp g' (x :: xs)
H: Γ Ⱶ
l₁ ++
(name ∶ {| irs_flattened := f; irs_pf := pf |})
:: l₂--------------------------------------
foldr patt_and x xs
using i

Hwf1: well_formed g'
wfr: well_formed
  {| irs_flattened := f; irs_pf := pf |}
Hwf2: foldr andb true
  (map well_formed
     (map nh_patt
        (l₁ ++
         (name ∶ foldr patt_imp g' (x :: xs))
         :: l₂)))
foldr andb true
  (map well_formed
     (map nh_patt
        (l₁ ++
         (name ∶ {|
                   irs_flattened := f; irs_pf := pf
                 |}) :: l₂)))
    rewrite 2!map_app in Hwf2.
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
f: TaggedPattern
pf: f = foldr patt_imp g' (x :: xs)
H: Γ Ⱶ
l₁ ++
(name ∶ {| irs_flattened := f; irs_pf := pf |})
:: l₂--------------------------------------
foldr patt_and x xs
using i

Hwf1: well_formed g'
wfr: well_formed
  {| irs_flattened := f; irs_pf := pf |}
Hwf2: foldr andb true
  (map well_formed (map nh_patt l₁) ++
   map well_formed
     (map nh_patt
        ((name ∶ foldr patt_imp g' (x :: xs))
         :: l₂)))
foldr andb true
  (map well_formed
     (map nh_patt
        (l₁ ++
         (name ∶ {|
                   irs_flattened := f; irs_pf := pf
                 |}) :: l₂)))
    rewrite foldr_app in Hwf2.
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
f: TaggedPattern
pf: f = foldr patt_imp g' (x :: xs)
H: Γ Ⱶ
l₁ ++
(name ∶ {| irs_flattened := f; irs_pf := pf |})
:: l₂--------------------------------------
foldr patt_and x xs
using i

Hwf1: well_formed g'
wfr: well_formed
  {| irs_flattened := f; irs_pf := pf |}
Hwf2: foldr andb
  (foldr andb true
     (map well_formed
        (map nh_patt
           ((name ∶ foldr patt_imp g' (x :: xs))
            :: l₂))))
  (map well_formed (map nh_patt l₁))
foldr andb true
  (map well_formed
     (map nh_patt
        (l₁ ++
         (name ∶ {|
                   irs_flattened := f; irs_pf := pf
                 |}) :: l₂)))
    rewrite 2!map_app.
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
f: TaggedPattern
pf: f = foldr patt_imp g' (x :: xs)
H: Γ Ⱶ
l₁ ++
(name ∶ {| irs_flattened := f; irs_pf := pf |})
:: l₂--------------------------------------
foldr patt_and x xs
using i

Hwf1: well_formed g'
wfr: well_formed
  {| irs_flattened := f; irs_pf := pf |}
Hwf2: foldr andb
  (foldr andb true
     (map well_formed
        (map nh_patt
           ((name ∶ foldr patt_imp g' (x :: xs))
            :: l₂))))
  (map well_formed (map nh_patt l₁))
foldr andb true
  (map well_formed (map nh_patt l₁) ++
   map well_formed
     (map nh_patt
        ((name ∶ {|
                   irs_flattened := f; irs_pf := pf
                 |}) :: l₂)))
    rewrite foldr_app.
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
f: TaggedPattern
pf: f = foldr patt_imp g' (x :: xs)
H: Γ Ⱶ
l₁ ++
(name ∶ {| irs_flattened := f; irs_pf := pf |})
:: l₂--------------------------------------
foldr patt_and x xs
using i

Hwf1: well_formed g'
wfr: well_formed
  {| irs_flattened := f; irs_pf := pf |}
Hwf2: foldr andb
  (foldr andb true
     (map well_formed
        (map nh_patt
           ((name ∶ foldr patt_imp g' (x :: xs))
            :: l₂))))
  (map well_formed (map nh_patt l₁))
foldr andb
  (foldr andb true
     (map well_formed
        (map nh_patt
           ((name ∶ {|
                      irs_flattened := f; irs_pf := pf
                    |}) :: l₂))))
  (map well_formed (map nh_patt l₁))
    cbn in Hwf2.
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
f: TaggedPattern
pf: f = foldr patt_imp g' (x :: xs)
H: Γ Ⱶ
l₁ ++
(name ∶ {| irs_flattened := f; irs_pf := pf |})
:: l₂--------------------------------------
foldr patt_and x xs
using i

Hwf1: well_formed g'
wfr: well_formed
  {| irs_flattened := f; irs_pf := pf |}
Hwf2: foldr andb
  (well_formed (x ---> foldr patt_imp g' xs) &&
   foldr andb true
     (map well_formed (map nh_patt l₂)))
  (map well_formed (map nh_patt l₁))
foldr andb
  (foldr andb true
     (map well_formed
        (map nh_patt
           ((name ∶ {|
                      irs_flattened := f; irs_pf := pf
                    |}) :: l₂))))
  (map well_formed (map nh_patt l₁)) cbn.
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
f: TaggedPattern
pf: f = foldr patt_imp g' (x :: xs)
H: Γ Ⱶ
l₁ ++
(name ∶ {| irs_flattened := f; irs_pf := pf |})
:: l₂--------------------------------------
foldr patt_and x xs
using i

Hwf1: well_formed g'
wfr: well_formed
  {| irs_flattened := f; irs_pf := pf |}
Hwf2: foldr andb
  (well_formed (x ---> foldr patt_imp g' xs) &&
   foldr andb true
     (map well_formed (map nh_patt l₂)))
  (map well_formed (map nh_patt l₁))
foldr andb
  (well_formed f &&
   foldr andb true (map well_formed (map nh_patt l₂)))
  (map well_formed (map nh_patt l₁))
    rewrite foldr_andb_true_iff in Hwf2.
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
f: TaggedPattern
pf: f = foldr patt_imp g' (x :: xs)
H: Γ Ⱶ
l₁ ++
(name ∶ {| irs_flattened := f; irs_pf := pf |})
:: l₂--------------------------------------
foldr patt_and x xs
using i

Hwf1: well_formed g'
wfr: well_formed
  {| irs_flattened := f; irs_pf := pf |}
Hwf2: well_formed (x ---> foldr patt_imp g' xs) &&
foldr andb true
  (map well_formed (map nh_patt l₂)) &&
foldr andb true
  (map well_formed (map nh_patt l₁))
foldr andb
  (well_formed f &&
   foldr andb true (map well_formed (map nh_patt l₂)))
  (map well_formed (map nh_patt l₁))
    rewrite foldr_andb_true_iff.
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
f: TaggedPattern
pf: f = foldr patt_imp g' (x :: xs)
H: Γ Ⱶ
l₁ ++
(name ∶ {| irs_flattened := f; irs_pf := pf |})
:: l₂--------------------------------------
foldr patt_and x xs
using i

Hwf1: well_formed g'
wfr: well_formed
  {| irs_flattened := f; irs_pf := pf |}
Hwf2: well_formed (x ---> foldr patt_imp g' xs) &&
foldr andb true
  (map well_formed (map nh_patt l₂)) &&
foldr andb true
  (map well_formed (map nh_patt l₁))
well_formed f &&
foldr andb true (map well_formed (map nh_patt l₂)) &&
foldr andb true (map well_formed (map nh_patt l₁))
    wf_auto2.
  }
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
H: Γ Ⱶ
l₁ ++ (name ∶ r) :: l₂--------------------------------------
foldr patt_and x xs
using i

Hwf1: well_formed g'
Hwf2: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wfr: well_formed r
wffa: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
Γ
⊢i foldr patt_imp g'
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)) using i


  assert (well_formed x).
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
H: Γ Ⱶ
l₁ ++ (name ∶ r) :: l₂--------------------------------------
foldr patt_and x xs
using i

Hwf1: well_formed g'
Hwf2: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wfr: well_formed r
wffa: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
well_formed x
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
H: Γ Ⱶ
l₁ ++ (name ∶ r) :: l₂--------------------------------------
foldr patt_and x xs
using i

Hwf1: well_formed g'
Hwf2: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wfr: well_formed r
wffa: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
H0: well_formed x
Γ
⊢i foldr patt_imp g'
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)) using i
  {
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
H: Γ Ⱶ
l₁ ++ (name ∶ r) :: l₂--------------------------------------
foldr patt_and x xs
using i

Hwf1: well_formed g'
Hwf2: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wfr: well_formed r
wffa: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
well_formed x
    rewrite irs_pf in Hwf2.
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
H: Γ Ⱶ
l₁ ++ (name ∶ r) :: l₂--------------------------------------
foldr patt_and x xs
using i

Hwf1: well_formed g'
wfr: well_formed r
wffa: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
Hwf2: foldr andb true
  (map well_formed
     (map nh_patt
        (l₁ ++
         (name ∶ foldr patt_imp g' (x :: xs))
         :: l₂)))
well_formed x
    rewrite 2!map_app in Hwf2.
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
H: Γ Ⱶ
l₁ ++ (name ∶ r) :: l₂--------------------------------------
foldr patt_and x xs
using i

Hwf1: well_formed g'
wfr: well_formed r
wffa: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
Hwf2: foldr andb true
  (map well_formed (map nh_patt l₁) ++
   map well_formed
     (map nh_patt
        ((name ∶ foldr patt_imp g' (x :: xs))
         :: l₂)))
well_formed x
    rewrite foldr_app in Hwf2.
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
H: Γ Ⱶ
l₁ ++ (name ∶ r) :: l₂--------------------------------------
foldr patt_and x xs
using i

Hwf1: well_formed g'
wfr: well_formed r
wffa: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
Hwf2: foldr andb
  (foldr andb true
     (map well_formed
        (map nh_patt
           ((name ∶ foldr patt_imp g' (x :: xs))
            :: l₂))))
  (map well_formed (map nh_patt l₁))
well_formed x
    rewrite foldr_andb_true_iff in Hwf2.
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
H: Γ Ⱶ
l₁ ++ (name ∶ r) :: l₂--------------------------------------
foldr patt_and x xs
using i

Hwf1: well_formed g'
wfr: well_formed r
wffa: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
Hwf2: foldr andb true
  (map well_formed
     (map nh_patt
        ((name ∶ foldr patt_imp g' (x :: xs))
         :: l₂))) &&
foldr andb true
  (map well_formed (map nh_patt l₁))
well_formed x
    wf_auto2.
  }
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
H: Γ Ⱶ
l₁ ++ (name ∶ r) :: l₂--------------------------------------
foldr patt_and x xs
using i

Hwf1: well_formed g'
Hwf2: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wfr: well_formed r
wffa: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
H0: well_formed x
Γ
⊢i foldr patt_imp g'
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)) using i

  assert (Pattern.wf xs).
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
H: Γ Ⱶ
l₁ ++ (name ∶ r) :: l₂--------------------------------------
foldr patt_and x xs
using i

Hwf1: well_formed g'
Hwf2: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wfr: well_formed r
wffa: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
H0: well_formed x
wf xs
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
H: Γ Ⱶ
l₁ ++ (name ∶ r) :: l₂--------------------------------------
foldr patt_and x xs
using i

Hwf1: well_formed g'
Hwf2: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wfr: well_formed r
wffa: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
H0: well_formed x
H1: wf xs
Γ
⊢i foldr patt_imp g'
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)) using i
  {
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
H: Γ Ⱶ
l₁ ++ (name ∶ r) :: l₂--------------------------------------
foldr patt_and x xs
using i

Hwf1: well_formed g'
Hwf2: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wfr: well_formed r
wffa: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
H0: well_formed x
wf xs
    rewrite irs_pf in Hwf2.
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
H: Γ Ⱶ
l₁ ++ (name ∶ r) :: l₂--------------------------------------
foldr patt_and x xs
using i

Hwf1: well_formed g'
wfr: well_formed r
wffa: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
H0: well_formed x
Hwf2: foldr andb true
  (map well_formed
     (map nh_patt
        (l₁ ++
         (name ∶ foldr patt_imp g' (x :: xs))
         :: l₂)))
wf xs
    rewrite 2!map_app in Hwf2.
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
H: Γ Ⱶ
l₁ ++ (name ∶ r) :: l₂--------------------------------------
foldr patt_and x xs
using i

Hwf1: well_formed g'
wfr: well_formed r
wffa: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
H0: well_formed x
Hwf2: foldr andb true
  (map well_formed (map nh_patt l₁) ++
   map well_formed
     (map nh_patt
        ((name ∶ foldr patt_imp g' (x :: xs))
         :: l₂)))
wf xs
    rewrite foldr_app in Hwf2.
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
H: Γ Ⱶ
l₁ ++ (name ∶ r) :: l₂--------------------------------------
foldr patt_and x xs
using i

Hwf1: well_formed g'
wfr: well_formed r
wffa: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
H0: well_formed x
Hwf2: foldr andb
  (foldr andb true
     (map well_formed
        (map nh_patt
           ((name ∶ foldr patt_imp g' (x :: xs))
            :: l₂))))
  (map well_formed (map nh_patt l₁))
wf xs
    rewrite foldr_andb_true_iff in Hwf2.
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
H: Γ Ⱶ
l₁ ++ (name ∶ r) :: l₂--------------------------------------
foldr patt_and x xs
using i

Hwf1: well_formed g'
wfr: well_formed r
wffa: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
H0: well_formed x
Hwf2: foldr andb true
  (map well_formed
     (map nh_patt
        ((name ∶ foldr patt_imp g' (x :: xs))
         :: l₂))) &&
foldr andb true
  (map well_formed (map nh_patt l₁))
wf xs
    wf_auto2.
  }
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
H: Γ Ⱶ
l₁ ++ (name ∶ r) :: l₂--------------------------------------
foldr patt_and x xs
using i

Hwf1: well_formed g'
Hwf2: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wfr: well_formed r
wffa: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
H0: well_formed x
H1: wf xs
Γ
⊢i foldr patt_imp g'
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)) using i

  feed specialize H.
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
H: Γ Ⱶ
l₁ ++ (name ∶ r) :: l₂--------------------------------------
foldr patt_and x xs
using i

Hwf1: well_formed g'
Hwf2: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wfr: well_formed r
wffa: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
H0: well_formed x
H1: wf xs
well_formed
  (mlConclusion
     (Γ Ⱶ
      l₁ ++ (name ∶ r) :: l₂--------------------------------------
      foldr patt_and x xs
      using i
      ))
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
H: Γ Ⱶ
l₁ ++ (name ∶ r) :: l₂--------------------------------------
foldr patt_and x xs
using i

Hwf1: well_formed g'
Hwf2: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wfr: well_formed r
wffa: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
H0: well_formed x
H1: wf xs
wf
  (patterns_of
     (mlHypotheses
        (Γ Ⱶ
         l₁ ++ (name ∶ r) :: l₂--------------------------------------
         foldr patt_and x xs
         using i
         )))
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
H: mlTheory
  (Γ Ⱶ
   l₁ ++ (name ∶ r) :: l₂--------------------------------------
   foldr patt_and x xs
   using i
   )
⊢i foldr patt_imp
     (mlConclusion
        (Γ Ⱶ
         l₁ ++ (name ∶ r) :: l₂--------------------------------------
         foldr patt_and x xs
         using i
         ))
     (patterns_of
        (mlHypotheses
           (Γ Ⱶ
            l₁ ++ (name ∶ r) :: l₂--------------------------------------
            foldr patt_and x xs
            using i
            )))
using mlInfo
        (Γ Ⱶ
         l₁ ++ (name ∶ r) :: l₂--------------------------------------
         foldr patt_and x xs
         using i
         )
Hwf1: well_formed g'
Hwf2: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wfr: well_formed r
wffa: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
H0: well_formed x
H1: wf xs
Γ
⊢i foldr patt_imp g'
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)) using i
  {
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
H: Γ Ⱶ
l₁ ++ (name ∶ r) :: l₂--------------------------------------
foldr patt_and x xs
using i

Hwf1: well_formed g'
Hwf2: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wfr: well_formed r
wffa: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
H0: well_formed x
H1: wf xs
well_formed
  (mlConclusion
     (Γ Ⱶ
      l₁ ++ (name ∶ r) :: l₂--------------------------------------
      foldr patt_and x xs
      using i
      ))
    cbn.
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
H: Γ Ⱶ
l₁ ++ (name ∶ r) :: l₂--------------------------------------
foldr patt_and x xs
using i

Hwf1: well_formed g'
Hwf2: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wfr: well_formed r
wffa: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
H0: well_formed x
H1: wf xs
well_formed (foldr patt_and x xs) wf_auto2.
  }
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
H: Γ Ⱶ
l₁ ++ (name ∶ r) :: l₂--------------------------------------
foldr patt_and x xs
using i

Hwf1: well_formed g'
Hwf2: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wfr: well_formed r
wffa: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
H0: well_formed x
H1: wf xs
wf
  (patterns_of
     (mlHypotheses
        (Γ Ⱶ
         l₁ ++ (name ∶ r) :: l₂--------------------------------------
         foldr patt_and x xs
         using i
         )))
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
H: mlTheory
  (Γ Ⱶ
   l₁ ++ (name ∶ r) :: l₂--------------------------------------
   foldr patt_and x xs
   using i
   )
⊢i foldr patt_imp
     (mlConclusion
        (Γ Ⱶ
         l₁ ++ (name ∶ r) :: l₂--------------------------------------
         foldr patt_and x xs
         using i
         ))
     (patterns_of
        (mlHypotheses
           (Γ Ⱶ
            l₁ ++ (name ∶ r) :: l₂--------------------------------------
            foldr patt_and x xs
            using i
            )))
using mlInfo
        (Γ Ⱶ
         l₁ ++ (name ∶ r) :: l₂--------------------------------------
         foldr patt_and x xs
         using i
         )
Hwf1: well_formed g'
Hwf2: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wfr: well_formed r
wffa: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
H0: well_formed x
H1: wf xs
Γ
⊢i foldr patt_imp g'
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)) using i
  {
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
H: Γ Ⱶ
l₁ ++ (name ∶ r) :: l₂--------------------------------------
foldr patt_and x xs
using i

Hwf1: well_formed g'
Hwf2: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wfr: well_formed r
wffa: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
H0: well_formed x
H1: wf xs
wf
  (patterns_of
     (mlHypotheses
        (Γ Ⱶ
         l₁ ++ (name ∶ r) :: l₂--------------------------------------
         foldr patt_and x xs
         using i
         ))) cbn.
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
H: Γ Ⱶ
l₁ ++ (name ∶ r) :: l₂--------------------------------------
foldr patt_and x xs
using i

Hwf1: well_formed g'
Hwf2: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wfr: well_formed r
wffa: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
H0: well_formed x
H1: wf xs
foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂))) assumption. }
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
H: mlTheory
  (Γ Ⱶ
   l₁ ++ (name ∶ r) :: l₂--------------------------------------
   foldr patt_and x xs
   using i
   )
⊢i foldr patt_imp
     (mlConclusion
        (Γ Ⱶ
         l₁ ++ (name ∶ r) :: l₂--------------------------------------
         foldr patt_and x xs
         using i
         ))
     (patterns_of
        (mlHypotheses
           (Γ Ⱶ
            l₁ ++ (name ∶ r) :: l₂--------------------------------------
            foldr patt_and x xs
            using i
            )))
using mlInfo
        (Γ Ⱶ
         l₁ ++ (name ∶ r) :: l₂--------------------------------------
         foldr patt_and x xs
         using i
         )
Hwf1: well_formed g'
Hwf2: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wfr: well_formed r
wffa: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
H0: well_formed x
H1: wf xs
Γ
⊢i foldr patt_imp g'
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)) using i
  cbn in H.
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
H: Γ
⊢i foldr patt_imp (foldr patt_and x xs)
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂))
using i
Hwf1: well_formed g'
Hwf2: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wfr: well_formed r
wffa: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
H0: well_formed x
H1: wf xs
Γ
⊢i foldr patt_imp g'
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)) using i


  assert (Hwfl₁ : wf (map nh_patt l₁) = true).
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
H: Γ
⊢i foldr patt_imp (foldr patt_and x xs)
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂))
using i
Hwf1: well_formed g'
Hwf2: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wfr: well_formed r
wffa: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
H0: well_formed x
H1: wf xs
wf (map nh_patt l₁) = true
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
H: Γ
⊢i foldr patt_imp (foldr patt_and x xs)
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂))
using i
Hwf1: well_formed g'
Hwf2: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wfr: well_formed r
wffa: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
H0: well_formed x
H1: wf xs
Hwfl₁: wf (map nh_patt l₁) = true
Γ
⊢i foldr patt_imp g'
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)) using i
  {
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
H: Γ
⊢i foldr patt_imp (foldr patt_and x xs)
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂))
using i
Hwf1: well_formed g'
Hwf2: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wfr: well_formed r
wffa: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
H0: well_formed x
H1: wf xs
wf (map nh_patt l₁) = true
    cbn.
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
H: Γ
⊢i foldr patt_imp (foldr patt_and x xs)
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂))
using i
Hwf1: well_formed g'
Hwf2: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wfr: well_formed r
wffa: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
H0: well_formed x
H1: wf xs
wf (map nh_patt l₁) = true
    destruct r as [f pf].
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
f: TaggedPattern
pf: f = foldr patt_imp g' (x :: xs)
H: Γ
⊢i foldr patt_imp (foldr patt_and x xs)
     (map nh_patt
        (l₁ ++
         (name ∶ {|
                   irs_flattened := f;
                   irs_pf := pf
                 |}) :: l₂)) using i
Hwf1: well_formed g'
Hwf2: foldr andb true
  (map well_formed
     (map nh_patt
        (l₁ ++
         (name ∶ {|
                   irs_flattened := f;
                   irs_pf := pf
                 |}) :: l₂)))
wfr: well_formed
  {| irs_flattened := f; irs_pf := pf |}
wffa: foldr andb true
  (map well_formed
     (map nh_patt
        (l₁ ++
         (name ∶ {|
                   irs_flattened := f;
                   irs_pf := pf
                 |}) :: l₂)))
H0: well_formed x
H1: wf xs
wf (map nh_patt l₁) = true
    rewrite pf in Hwf2.
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
f: TaggedPattern
pf: f = foldr patt_imp g' (x :: xs)
H: Γ
⊢i foldr patt_imp (foldr patt_and x xs)
     (map nh_patt
        (l₁ ++
         (name ∶ {|
                   irs_flattened := f;
                   irs_pf := pf
                 |}) :: l₂)) using i
Hwf1: well_formed g'
wfr: well_formed
  {| irs_flattened := f; irs_pf := pf |}
wffa: foldr andb true
  (map well_formed
     (map nh_patt
        (l₁ ++
         (name ∶ {|
                   irs_flattened := f;
                   irs_pf := pf
                 |}) :: l₂)))
H0: well_formed x
H1: wf xs
Hwf2: foldr andb true
  (map well_formed
     (map nh_patt
        (l₁ ++
         (name ∶ foldr patt_imp g' (x :: xs))
         :: l₂)))
wf (map nh_patt l₁) = true
    rewrite 2!map_app in Hwf2.
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
f: TaggedPattern
pf: f = foldr patt_imp g' (x :: xs)
H: Γ
⊢i foldr patt_imp (foldr patt_and x xs)
     (map nh_patt
        (l₁ ++
         (name ∶ {|
                   irs_flattened := f;
                   irs_pf := pf
                 |}) :: l₂)) using i
Hwf1: well_formed g'
wfr: well_formed
  {| irs_flattened := f; irs_pf := pf |}
wffa: foldr andb true
  (map well_formed
     (map nh_patt
        (l₁ ++
         (name ∶ {|
                   irs_flattened := f;
                   irs_pf := pf
                 |}) :: l₂)))
H0: well_formed x
H1: wf xs
Hwf2: foldr andb true
  (map well_formed (map nh_patt l₁) ++
   map well_formed
     (map nh_patt
        ((name ∶ foldr patt_imp g' (x :: xs))
         :: l₂)))
wf (map nh_patt l₁) = true
    rewrite foldr_app in Hwf2.
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
f: TaggedPattern
pf: f = foldr patt_imp g' (x :: xs)
H: Γ
⊢i foldr patt_imp (foldr patt_and x xs)
     (map nh_patt
        (l₁ ++
         (name ∶ {|
                   irs_flattened := f;
                   irs_pf := pf
                 |}) :: l₂)) using i
Hwf1: well_formed g'
wfr: well_formed
  {| irs_flattened := f; irs_pf := pf |}
wffa: foldr andb true
  (map well_formed
     (map nh_patt
        (l₁ ++
         (name ∶ {|
                   irs_flattened := f;
                   irs_pf := pf
                 |}) :: l₂)))
H0: well_formed x
H1: wf xs
Hwf2: foldr andb
  (foldr andb true
     (map well_formed
        (map nh_patt
           ((name ∶ foldr patt_imp g' (x :: xs))
            :: l₂))))
  (map well_formed (map nh_patt l₁))
wf (map nh_patt l₁) = true
    rewrite foldr_andb_true_iff in Hwf2.
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
f: TaggedPattern
pf: f = foldr patt_imp g' (x :: xs)
H: Γ
⊢i foldr patt_imp (foldr patt_and x xs)
     (map nh_patt
        (l₁ ++
         (name ∶ {|
                   irs_flattened := f;
                   irs_pf := pf
                 |}) :: l₂)) using i
Hwf1: well_formed g'
wfr: well_formed
  {| irs_flattened := f; irs_pf := pf |}
wffa: foldr andb true
  (map well_formed
     (map nh_patt
        (l₁ ++
         (name ∶ {|
                   irs_flattened := f;
                   irs_pf := pf
                 |}) :: l₂)))
H0: well_formed x
H1: wf xs
Hwf2: foldr andb true
  (map well_formed
     (map nh_patt
        ((name ∶ foldr patt_imp g' (x :: xs))
         :: l₂))) &&
foldr andb true
  (map well_formed (map nh_patt l₁))
wf (map nh_patt l₁) = true
    cbn in *.
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
f: TaggedPattern
pf: f = (x ---> foldr patt_imp g' xs)
H: Γ
⊢i foldr patt_imp (foldr patt_and x xs)
     (map nh_patt (l₁ ++ (name ∶ f) :: l₂))
using i
Hwf1: well_formed g'
wfr: well_formed f
wffa: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ f) :: l₂)))
H0: well_formed x
H1: wf xs
Hwf2: well_formed (x ---> foldr patt_imp g' xs) &&
foldr andb true
  (map well_formed (map nh_patt l₂)) &&
foldr andb true
  (map well_formed (map nh_patt l₁))
wf (map nh_patt l₁) = true
    rewrite map_app in H.
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
f: TaggedPattern
pf: f = (x ---> foldr patt_imp g' xs)
Hwf1: well_formed g'
wfr: well_formed f
wffa: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ f) :: l₂)))
H0: well_formed x
H1: wf xs
Hwf2: well_formed (x ---> foldr patt_imp g' xs) &&
foldr andb true
  (map well_formed (map nh_patt l₂)) &&
foldr andb true
  (map well_formed (map nh_patt l₁))
H: Γ
⊢i foldr patt_imp (foldr patt_and x xs)
     (map nh_patt l₁ ++
      map nh_patt ((name ∶ f) :: l₂)) using i
wf (map nh_patt l₁) = true
    rewrite map_app in wffa.
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
f: TaggedPattern
pf: f = (x ---> foldr patt_imp g' xs)
Hwf1: well_formed g'
wfr: well_formed f
H0: well_formed x
H1: wf xs
Hwf2: well_formed (x ---> foldr patt_imp g' xs) &&
foldr andb true
  (map well_formed (map nh_patt l₂)) &&
foldr andb true
  (map well_formed (map nh_patt l₁))
H: Γ
⊢i foldr patt_imp (foldr patt_and x xs)
     (map nh_patt l₁ ++
      map nh_patt ((name ∶ f) :: l₂)) using i
wffa: foldr andb true
  (map well_formed
     (map nh_patt l₁ ++
      map nh_patt ((name ∶ f) :: l₂)))
wf (map nh_patt l₁) = true
    wf_auto2.
  }
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
H: Γ
⊢i foldr patt_imp (foldr patt_and x xs)
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂))
using i
Hwf1: well_formed g'
Hwf2: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wfr: well_formed r
wffa: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
H0: well_formed x
H1: wf xs
Hwfl₁: wf (map nh_patt l₁) = true
Γ
⊢i foldr patt_imp g'
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)) using i

  assert (Hwfl₂ : wf (map nh_patt l₂) = true).
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
H: Γ
⊢i foldr patt_imp (foldr patt_and x xs)
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂))
using i
Hwf1: well_formed g'
Hwf2: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wfr: well_formed r
wffa: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
H0: well_formed x
H1: wf xs
Hwfl₁: wf (map nh_patt l₁) = true
wf (map nh_patt l₂) = true
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
H: Γ
⊢i foldr patt_imp (foldr patt_and x xs)
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂))
using i
Hwf1: well_formed g'
Hwf2: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wfr: well_formed r
wffa: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
H0: well_formed x
H1: wf xs
Hwfl₁: wf (map nh_patt l₁) = true
Hwfl₂: wf (map nh_patt l₂) = true
Γ
⊢i foldr patt_imp g'
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)) using i
  {
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
H: Γ
⊢i foldr patt_imp (foldr patt_and x xs)
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂))
using i
Hwf1: well_formed g'
Hwf2: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wfr: well_formed r
wffa: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
H0: well_formed x
H1: wf xs
Hwfl₁: wf (map nh_patt l₁) = true
wf (map nh_patt l₂) = true
    cbn.
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
H: Γ
⊢i foldr patt_imp (foldr patt_and x xs)
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂))
using i
Hwf1: well_formed g'
Hwf2: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wfr: well_formed r
wffa: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
H0: well_formed x
H1: wf xs
Hwfl₁: wf (map nh_patt l₁) = true
wf (map nh_patt l₂) = true
    destruct r as [f pf].
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
f: TaggedPattern
pf: f = foldr patt_imp g' (x :: xs)
H: Γ
⊢i foldr patt_imp (foldr patt_and x xs)
     (map nh_patt
        (l₁ ++
         (name ∶ {|
                   irs_flattened := f;
                   irs_pf := pf
                 |}) :: l₂)) using i
Hwf1: well_formed g'
Hwf2: foldr andb true
  (map well_formed
     (map nh_patt
        (l₁ ++
         (name ∶ {|
                   irs_flattened := f;
                   irs_pf := pf
                 |}) :: l₂)))
wfr: well_formed
  {| irs_flattened := f; irs_pf := pf |}
wffa: foldr andb true
  (map well_formed
     (map nh_patt
        (l₁ ++
         (name ∶ {|
                   irs_flattened := f;
                   irs_pf := pf
                 |}) :: l₂)))
H0: well_formed x
H1: wf xs
Hwfl₁: wf (map nh_patt l₁) = true
wf (map nh_patt l₂) = true
    rewrite pf in Hwf2.
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
f: TaggedPattern
pf: f = foldr patt_imp g' (x :: xs)
H: Γ
⊢i foldr patt_imp (foldr patt_and x xs)
     (map nh_patt
        (l₁ ++
         (name ∶ {|
                   irs_flattened := f;
                   irs_pf := pf
                 |}) :: l₂)) using i
Hwf1: well_formed g'
wfr: well_formed
  {| irs_flattened := f; irs_pf := pf |}
wffa: foldr andb true
  (map well_formed
     (map nh_patt
        (l₁ ++
         (name ∶ {|
                   irs_flattened := f;
                   irs_pf := pf
                 |}) :: l₂)))
H0: well_formed x
H1: wf xs
Hwfl₁: wf (map nh_patt l₁) = true
Hwf2: foldr andb true
  (map well_formed
     (map nh_patt
        (l₁ ++
         (name ∶ foldr patt_imp g' (x :: xs))
         :: l₂)))
wf (map nh_patt l₂) = true
    rewrite 2!map_app in Hwf2.
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
f: TaggedPattern
pf: f = foldr patt_imp g' (x :: xs)
H: Γ
⊢i foldr patt_imp (foldr patt_and x xs)
     (map nh_patt
        (l₁ ++
         (name ∶ {|
                   irs_flattened := f;
                   irs_pf := pf
                 |}) :: l₂)) using i
Hwf1: well_formed g'
wfr: well_formed
  {| irs_flattened := f; irs_pf := pf |}
wffa: foldr andb true
  (map well_formed
     (map nh_patt
        (l₁ ++
         (name ∶ {|
                   irs_flattened := f;
                   irs_pf := pf
                 |}) :: l₂)))
H0: well_formed x
H1: wf xs
Hwfl₁: wf (map nh_patt l₁) = true
Hwf2: foldr andb true
  (map well_formed (map nh_patt l₁) ++
   map well_formed
     (map nh_patt
        ((name ∶ foldr patt_imp g' (x :: xs))
         :: l₂)))
wf (map nh_patt l₂) = true
    rewrite foldr_app in Hwf2.
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
f: TaggedPattern
pf: f = foldr patt_imp g' (x :: xs)
H: Γ
⊢i foldr patt_imp (foldr patt_and x xs)
     (map nh_patt
        (l₁ ++
         (name ∶ {|
                   irs_flattened := f;
                   irs_pf := pf
                 |}) :: l₂)) using i
Hwf1: well_formed g'
wfr: well_formed
  {| irs_flattened := f; irs_pf := pf |}
wffa: foldr andb true
  (map well_formed
     (map nh_patt
        (l₁ ++
         (name ∶ {|
                   irs_flattened := f;
                   irs_pf := pf
                 |}) :: l₂)))
H0: well_formed x
H1: wf xs
Hwfl₁: wf (map nh_patt l₁) = true
Hwf2: foldr andb
  (foldr andb true
     (map well_formed
        (map nh_patt
           ((name ∶ foldr patt_imp g' (x :: xs))
            :: l₂))))
  (map well_formed (map nh_patt l₁))
wf (map nh_patt l₂) = true
    rewrite foldr_andb_true_iff in Hwf2.
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
f: TaggedPattern
pf: f = foldr patt_imp g' (x :: xs)
H: Γ
⊢i foldr patt_imp (foldr patt_and x xs)
     (map nh_patt
        (l₁ ++
         (name ∶ {|
                   irs_flattened := f;
                   irs_pf := pf
                 |}) :: l₂)) using i
Hwf1: well_formed g'
wfr: well_formed
  {| irs_flattened := f; irs_pf := pf |}
wffa: foldr andb true
  (map well_formed
     (map nh_patt
        (l₁ ++
         (name ∶ {|
                   irs_flattened := f;
                   irs_pf := pf
                 |}) :: l₂)))
H0: well_formed x
H1: wf xs
Hwfl₁: wf (map nh_patt l₁) = true
Hwf2: foldr andb true
  (map well_formed
     (map nh_patt
        ((name ∶ foldr patt_imp g' (x :: xs))
         :: l₂))) &&
foldr andb true
  (map well_formed (map nh_patt l₁))
wf (map nh_patt l₂) = true
    cbn in *.
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
f: TaggedPattern
pf: f = (x ---> foldr patt_imp g' xs)
H: Γ
⊢i foldr patt_imp (foldr patt_and x xs)
     (map nh_patt (l₁ ++ (name ∶ f) :: l₂))
using i
Hwf1: well_formed g'
wfr: well_formed f
wffa: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ f) :: l₂)))
H0: well_formed x
H1: wf xs
Hwfl₁: wf (map nh_patt l₁) = true
Hwf2: well_formed (x ---> foldr patt_imp g' xs) &&
foldr andb true
  (map well_formed (map nh_patt l₂)) &&
foldr andb true
  (map well_formed (map nh_patt l₁))
wf (map nh_patt l₂) = true
    rewrite map_app in H.
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
f: TaggedPattern
pf: f = (x ---> foldr patt_imp g' xs)
Hwf1: well_formed g'
wfr: well_formed f
wffa: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ f) :: l₂)))
H0: well_formed x
H1: wf xs
Hwfl₁: wf (map nh_patt l₁) = true
Hwf2: well_formed (x ---> foldr patt_imp g' xs) &&
foldr andb true
  (map well_formed (map nh_patt l₂)) &&
foldr andb true
  (map well_formed (map nh_patt l₁))
H: Γ
⊢i foldr patt_imp (foldr patt_and x xs)
     (map nh_patt l₁ ++
      map nh_patt ((name ∶ f) :: l₂)) using i
wf (map nh_patt l₂) = true
    rewrite map_app in wffa.
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
f: TaggedPattern
pf: f = (x ---> foldr patt_imp g' xs)
Hwf1: well_formed g'
wfr: well_formed f
H0: well_formed x
H1: wf xs
Hwfl₁: wf (map nh_patt l₁) = true
Hwf2: well_formed (x ---> foldr patt_imp g' xs) &&
foldr andb true
  (map well_formed (map nh_patt l₂)) &&
foldr andb true
  (map well_formed (map nh_patt l₁))
H: Γ
⊢i foldr patt_imp (foldr patt_and x xs)
     (map nh_patt l₁ ++
      map nh_patt ((name ∶ f) :: l₂)) using i
wffa: foldr andb true
  (map well_formed
     (map nh_patt l₁ ++
      map nh_patt ((name ∶ f) :: l₂)))
wf (map nh_patt l₂) = true
    wf_auto2.
  }
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
H: Γ
⊢i foldr patt_imp (foldr patt_and x xs)
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂))
using i
Hwf1: well_formed g'
Hwf2: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wfr: well_formed r
wffa: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
H0: well_formed x
H1: wf xs
Hwfl₁: wf (map nh_patt l₁) = true
Hwfl₂: wf (map nh_patt l₂) = true
Γ
⊢i foldr patt_imp g'
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)) using i

  rewrite map_app.
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
H: Γ
⊢i foldr patt_imp (foldr patt_and x xs)
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂))
using i
Hwf1: well_formed g'
Hwf2: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wfr: well_formed r
wffa: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
H0: well_formed x
H1: wf xs
Hwfl₁: wf (map nh_patt l₁) = true
Hwfl₂: wf (map nh_patt l₂) = true
Γ
⊢i foldr patt_imp g'
     (map nh_patt l₁ ++ map nh_patt ((name ∶ r) :: l₂))
using i
  cbn.
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
H: Γ
⊢i foldr patt_imp (foldr patt_and x xs)
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂))
using i
Hwf1: well_formed g'
Hwf2: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wfr: well_formed r
wffa: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
H0: well_formed x
H1: wf xs
Hwfl₁: wf (map nh_patt l₁) = true
Hwfl₂: wf (map nh_patt l₂) = true
Γ
⊢i foldr patt_imp g'
     (map nh_patt l₁ ++ r :: map nh_patt l₂) using i rewrite map_app in H.
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
Hwf1: well_formed g'
Hwf2: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wfr: well_formed r
wffa: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
H0: well_formed x
H1: wf xs
Hwfl₁: wf (map nh_patt l₁) = true
Hwfl₂: wf (map nh_patt l₂) = true
H: Γ
⊢i foldr patt_imp (foldr patt_and x xs)
     (map nh_patt l₁ ++
      map nh_patt ((name ∶ r) :: l₂)) using i
Γ
⊢i foldr patt_imp g'
     (map nh_patt l₁ ++ r :: map nh_patt l₂) using i cbn in H.
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
Hwf1: well_formed g'
Hwf2: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wfr: well_formed r
wffa: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
H0: well_formed x
H1: wf xs
Hwfl₁: wf (map nh_patt l₁) = true
Hwfl₂: wf (map nh_patt l₂) = true
H: Γ
⊢i foldr patt_imp (foldr patt_and x xs)
     (map nh_patt l₁ ++ r :: map nh_patt l₂)
using i
Γ
⊢i foldr patt_imp g'
     (map nh_patt l₁ ++ r :: map nh_patt l₂) using i
  rewrite irs_pf.
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
Hwf1: well_formed g'
Hwf2: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wfr: well_formed r
wffa: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
H0: well_formed x
H1: wf xs
Hwfl₁: wf (map nh_patt l₁) = true
Hwfl₂: wf (map nh_patt l₂) = true
H: Γ
⊢i foldr patt_imp (foldr patt_and x xs)
     (map nh_patt l₁ ++ r :: map nh_patt l₂)
using i
Γ
⊢i foldr patt_imp g'
     (map nh_patt l₁ ++
      foldr patt_imp g' (x :: xs) :: map nh_patt l₂)
using i

  eapply prf_strenghten_premise_iter_meta_meta.
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
Hwf1: well_formed g'
Hwf2: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wfr: well_formed r
wffa: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
H0: well_formed x
H1: wf xs
Hwfl₁: wf (map nh_patt l₁) = true
Hwfl₂: wf (map nh_patt l₂) = true
H: Γ
⊢i foldr patt_imp (foldr patt_and x xs)
     (map nh_patt l₁ ++ r :: map nh_patt l₂)
using i
wf (map nh_patt l₁)
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
Hwf1: well_formed g'
Hwf2: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wfr: well_formed r
wffa: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
H0: well_formed x
H1: wf xs
Hwfl₁: wf (map nh_patt l₁) = true
Hwfl₂: wf (map nh_patt l₂) = true
H: Γ
⊢i foldr patt_imp (foldr patt_and x xs)
     (map nh_patt l₁ ++ r :: map nh_patt l₂)
using i
wf (map nh_patt l₂)
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
Hwf1: well_formed g'
Hwf2: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wfr: well_formed r
wffa: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
H0: well_formed x
H1: wf xs
Hwfl₁: wf (map nh_patt l₁) = true
Hwfl₂: wf (map nh_patt l₂) = true
H: Γ
⊢i foldr patt_imp (foldr patt_and x xs)
     (map nh_patt l₁ ++ r :: map nh_patt l₂)
using i
well_formed ?h
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
Hwf1: well_formed g'
Hwf2: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wfr: well_formed r
wffa: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
H0: well_formed x
H1: wf xs
Hwfl₁: wf (map nh_patt l₁) = true
Hwfl₂: wf (map nh_patt l₂) = true
H: Γ
⊢i foldr patt_imp (foldr patt_and x xs)
     (map nh_patt l₁ ++ r :: map nh_patt l₂)
using i
well_formed (foldr patt_imp g' (x :: xs))
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
Hwf1: well_formed g'
Hwf2: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wfr: well_formed r
wffa: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
H0: well_formed x
H1: wf xs
Hwfl₁: wf (map nh_patt l₁) = true
Hwfl₂: wf (map nh_patt l₂) = true
H: Γ
⊢i foldr patt_imp (foldr patt_and x xs)
     (map nh_patt l₁ ++ r :: map nh_patt l₂)
using i
well_formed g'
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
Hwf1: well_formed g'
Hwf2: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wfr: well_formed r
wffa: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
H0: well_formed x
H1: wf xs
Hwfl₁: wf (map nh_patt l₁) = true
Hwfl₂: wf (map nh_patt l₂) = true
H: Γ
⊢i foldr patt_imp (foldr patt_and x xs)
     (map nh_patt l₁ ++ r :: map nh_patt l₂)
using i
Γ ⊢i foldr patt_imp g' (x :: xs) ---> ?h using i
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
Hwf1: well_formed g'
Hwf2: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wfr: well_formed r
wffa: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
H0: well_formed x
H1: wf xs
Hwfl₁: wf (map nh_patt l₁) = true
Hwfl₂: wf (map nh_patt l₂) = true
H: Γ
⊢i foldr patt_imp (foldr patt_and x xs)
     (map nh_patt l₁ ++ r :: map nh_patt l₂)
using i
Γ
⊢i foldr patt_imp g'
     (map nh_patt l₁ ++ ?h :: map nh_patt l₂) using i
  6: {
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
Hwf1: well_formed g'
Hwf2: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wfr: well_formed r
wffa: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
H0: well_formed x
H1: wf xs
Hwfl₁: wf (map nh_patt l₁) = true
Hwfl₂: wf (map nh_patt l₂) = true
H: Γ
⊢i foldr patt_imp (foldr patt_and x xs)
     (map nh_patt l₁ ++ r :: map nh_patt l₂)
using i
Γ ⊢i foldr patt_imp g' (x :: xs) ---> ?h using i
    useBasicReasoning.
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
Hwf1: well_formed g'
Hwf2: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wfr: well_formed r
wffa: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
H0: well_formed x
H1: wf xs
Hwfl₁: wf (map nh_patt l₁) = true
Hwfl₂: wf (map nh_patt l₂) = true
H: Γ
⊢i foldr patt_imp (foldr patt_and x xs)
     (map nh_patt l₁ ++ r :: map nh_patt l₂)
using i
Γ ⊢i foldr patt_imp g' (x :: xs) ---> ?h
using BasicReasoning
    apply lhs_imp_to_and.
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
Hwf1: well_formed g'
Hwf2: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wfr: well_formed r
wffa: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
H0: well_formed x
H1: wf xs
Hwfl₁: wf (map nh_patt l₁) = true
Hwfl₂: wf (map nh_patt l₂) = true
H: Γ
⊢i foldr patt_imp (foldr patt_and x xs)
     (map nh_patt l₁ ++ r :: map nh_patt l₂)
using i
well_formed g'
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
Hwf1: well_formed g'
Hwf2: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wfr: well_formed r
wffa: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
H0: well_formed x
H1: wf xs
Hwfl₁: wf (map nh_patt l₁) = true
Hwfl₂: wf (map nh_patt l₂) = true
H: Γ
⊢i foldr patt_imp (foldr patt_and x xs)
     (map nh_patt l₁ ++ r :: map nh_patt l₂)
using i
well_formed x
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
Hwf1: well_formed g'
Hwf2: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wfr: well_formed r
wffa: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
H0: well_formed x
H1: wf xs
Hwfl₁: wf (map nh_patt l₁) = true
Hwfl₂: wf (map nh_patt l₂) = true
H: Γ
⊢i foldr patt_imp (foldr patt_and x xs)
     (map nh_patt l₁ ++ r :: map nh_patt l₂)
using i
wf xs
    1-3: wf_auto2.
  }
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
Hwf1: well_formed g'
Hwf2: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wfr: well_formed r
wffa: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
H0: well_formed x
H1: wf xs
Hwfl₁: wf (map nh_patt l₁) = true
Hwfl₂: wf (map nh_patt l₂) = true
H: Γ
⊢i foldr patt_imp (foldr patt_and x xs)
     (map nh_patt l₁ ++ r :: map nh_patt l₂)
using i
wf (map nh_patt l₁)
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
Hwf1: well_formed g'
Hwf2: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wfr: well_formed r
wffa: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
H0: well_formed x
H1: wf xs
Hwfl₁: wf (map nh_patt l₁) = true
Hwfl₂: wf (map nh_patt l₂) = true
H: Γ
⊢i foldr patt_imp (foldr patt_and x xs)
     (map nh_patt l₁ ++ r :: map nh_patt l₂)
using i
wf (map nh_patt l₂)
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
Hwf1: well_formed g'
Hwf2: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wfr: well_formed r
wffa: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
H0: well_formed x
H1: wf xs
Hwfl₁: wf (map nh_patt l₁) = true
Hwfl₂: wf (map nh_patt l₂) = true
H: Γ
⊢i foldr patt_imp (foldr patt_and x xs)
     (map nh_patt l₁ ++ r :: map nh_patt l₂)
using i
well_formed (foldr patt_and x xs ---> g')
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
Hwf1: well_formed g'
Hwf2: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wfr: well_formed r
wffa: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
H0: well_formed x
H1: wf xs
Hwfl₁: wf (map nh_patt l₁) = true
Hwfl₂: wf (map nh_patt l₂) = true
H: Γ
⊢i foldr patt_imp (foldr patt_and x xs)
     (map nh_patt l₁ ++ r :: map nh_patt l₂)
using i
well_formed (foldr patt_imp g' (x :: xs))
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
Hwf1: well_formed g'
Hwf2: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wfr: well_formed r
wffa: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
H0: well_formed x
H1: wf xs
Hwfl₁: wf (map nh_patt l₁) = true
Hwfl₂: wf (map nh_patt l₂) = true
H: Γ
⊢i foldr patt_imp (foldr patt_and x xs)
     (map nh_patt l₁ ++ r :: map nh_patt l₂)
using i
well_formed g'
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
Hwf1: well_formed g'
Hwf2: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wfr: well_formed r
wffa: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
H0: well_formed x
H1: wf xs
Hwfl₁: wf (map nh_patt l₁) = true
Hwfl₂: wf (map nh_patt l₂) = true
H: Γ
⊢i foldr patt_imp (foldr patt_and x xs)
     (map nh_patt l₁ ++ r :: map nh_patt l₂)
using i
Γ
⊢i foldr patt_imp g'
     (map nh_patt l₁ ++
      (foldr patt_and x xs ---> g') :: map nh_patt l₂)
using i
  1-5: wf_auto2.
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
Hwf1: well_formed g'
Hwf2: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wfr: well_formed r
wffa: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
H0: well_formed x
H1: wf xs
Hwfl₁: wf (map nh_patt l₁) = true
Hwfl₂: wf (map nh_patt l₂) = true
H: Γ
⊢i foldr patt_imp (foldr patt_and x xs)
     (map nh_patt l₁ ++ r :: map nh_patt l₂)
using i
Γ
⊢i foldr patt_imp g'
     (map nh_patt l₁ ++
      (foldr patt_and x xs ---> g') :: map nh_patt l₂)
using i

  apply prf_weaken_conclusion_iter_under_implication_iter_meta.
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
Hwf1: well_formed g'
Hwf2: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wfr: well_formed r
wffa: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
H0: well_formed x
H1: wf xs
Hwfl₁: wf (map nh_patt l₁) = true
Hwfl₂: wf (map nh_patt l₂) = true
H: Γ
⊢i foldr patt_imp (foldr patt_and x xs)
     (map nh_patt l₁ ++ r :: map nh_patt l₂)
using i
wf (map nh_patt l₁)
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
Hwf1: well_formed g'
Hwf2: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wfr: well_formed r
wffa: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
H0: well_formed x
H1: wf xs
Hwfl₁: wf (map nh_patt l₁) = true
Hwfl₂: wf (map nh_patt l₂) = true
H: Γ
⊢i foldr patt_imp (foldr patt_and x xs)
     (map nh_patt l₁ ++ r :: map nh_patt l₂)
using i
wf (map nh_patt l₂)
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
Hwf1: well_formed g'
Hwf2: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wfr: well_formed r
wffa: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
H0: well_formed x
H1: wf xs
Hwfl₁: wf (map nh_patt l₁) = true
Hwfl₂: wf (map nh_patt l₂) = true
H: Γ
⊢i foldr patt_imp (foldr patt_and x xs)
     (map nh_patt l₁ ++ r :: map nh_patt l₂)
using i
well_formed (foldr patt_and x xs)
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
Hwf1: well_formed g'
Hwf2: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wfr: well_formed r
wffa: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
H0: well_formed x
H1: wf xs
Hwfl₁: wf (map nh_patt l₁) = true
Hwfl₂: wf (map nh_patt l₂) = true
H: Γ
⊢i foldr patt_imp (foldr patt_and x xs)
     (map nh_patt l₁ ++ r :: map nh_patt l₂)
using i
well_formed g'
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
Hwf1: well_formed g'
Hwf2: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wfr: well_formed r
wffa: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
H0: well_formed x
H1: wf xs
Hwfl₁: wf (map nh_patt l₁) = true
Hwfl₂: wf (map nh_patt l₂) = true
H: Γ
⊢i foldr patt_imp (foldr patt_and x xs)
     (map nh_patt l₁ ++ r :: map nh_patt l₂)
using i
Γ
⊢i foldr patt_imp (foldr patt_and x xs)
     (map nh_patt l₁ ++
      (foldr patt_and x xs ---> g') :: map nh_patt l₂)
using i
  1-4: wf_auto2.
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
Hwf1: well_formed g'
Hwf2: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wfr: well_formed r
wffa: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
H0: well_formed x
H1: wf xs
Hwfl₁: wf (map nh_patt l₁) = true
Hwfl₂: wf (map nh_patt l₂) = true
H: Γ
⊢i foldr patt_imp (foldr patt_and x xs)
     (map nh_patt l₁ ++ r :: map nh_patt l₂)
using i
Γ
⊢i foldr patt_imp (foldr patt_and x xs)
     (map nh_patt l₁ ++
      (foldr patt_and x xs ---> g') :: map nh_patt l₂)
using i

  eapply prf_strenghten_premise_iter_meta_meta.
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
Hwf1: well_formed g'
Hwf2: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wfr: well_formed r
wffa: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
H0: well_formed x
H1: wf xs
Hwfl₁: wf (map nh_patt l₁) = true
Hwfl₂: wf (map nh_patt l₂) = true
H: Γ
⊢i foldr patt_imp (foldr patt_and x xs)
     (map nh_patt l₁ ++ r :: map nh_patt l₂)
using i
wf (map nh_patt l₁)
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
Hwf1: well_formed g'
Hwf2: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wfr: well_formed r
wffa: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
H0: well_formed x
H1: wf xs
Hwfl₁: wf (map nh_patt l₁) = true
Hwfl₂: wf (map nh_patt l₂) = true
H: Γ
⊢i foldr patt_imp (foldr patt_and x xs)
     (map nh_patt l₁ ++ r :: map nh_patt l₂)
using i
wf (map nh_patt l₂)
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
Hwf1: well_formed g'
Hwf2: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wfr: well_formed r
wffa: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
H0: well_formed x
H1: wf xs
Hwfl₁: wf (map nh_patt l₁) = true
Hwfl₂: wf (map nh_patt l₂) = true
H: Γ
⊢i foldr patt_imp (foldr patt_and x xs)
     (map nh_patt l₁ ++ r :: map nh_patt l₂)
using i
well_formed ?h
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
Hwf1: well_formed g'
Hwf2: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wfr: well_formed r
wffa: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
H0: well_formed x
H1: wf xs
Hwfl₁: wf (map nh_patt l₁) = true
Hwfl₂: wf (map nh_patt l₂) = true
H: Γ
⊢i foldr patt_imp (foldr patt_and x xs)
     (map nh_patt l₁ ++ r :: map nh_patt l₂)
using i
well_formed (foldr patt_and x xs ---> g')
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
Hwf1: well_formed g'
Hwf2: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wfr: well_formed r
wffa: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
H0: well_formed x
H1: wf xs
Hwfl₁: wf (map nh_patt l₁) = true
Hwfl₂: wf (map nh_patt l₂) = true
H: Γ
⊢i foldr patt_imp (foldr patt_and x xs)
     (map nh_patt l₁ ++ r :: map nh_patt l₂)
using i
well_formed (foldr patt_and x xs)
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
Hwf1: well_formed g'
Hwf2: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wfr: well_formed r
wffa: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
H0: well_formed x
H1: wf xs
Hwfl₁: wf (map nh_patt l₁) = true
Hwfl₂: wf (map nh_patt l₂) = true
H: Γ
⊢i foldr patt_imp (foldr patt_and x xs)
     (map nh_patt l₁ ++ r :: map nh_patt l₂)
using i
Γ ⊢i (foldr patt_and x xs ---> g') ---> ?h using i
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
Hwf1: well_formed g'
Hwf2: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wfr: well_formed r
wffa: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
H0: well_formed x
H1: wf xs
Hwfl₁: wf (map nh_patt l₁) = true
Hwfl₂: wf (map nh_patt l₂) = true
H: Γ
⊢i foldr patt_imp (foldr patt_and x xs)
     (map nh_patt l₁ ++ r :: map nh_patt l₂)
using i
Γ
⊢i foldr patt_imp (foldr patt_and x xs)
     (map nh_patt l₁ ++ ?h :: map nh_patt l₂) using i
  6: {
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
Hwf1: well_formed g'
Hwf2: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wfr: well_formed r
wffa: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
H0: well_formed x
H1: wf xs
Hwfl₁: wf (map nh_patt l₁) = true
Hwfl₂: wf (map nh_patt l₂) = true
H: Γ
⊢i foldr patt_imp (foldr patt_and x xs)
     (map nh_patt l₁ ++ r :: map nh_patt l₂)
using i
Γ ⊢i (foldr patt_and x xs ---> g') ---> ?h using i
    useBasicReasoning.
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
Hwf1: well_formed g'
Hwf2: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wfr: well_formed r
wffa: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
H0: well_formed x
H1: wf xs
Hwfl₁: wf (map nh_patt l₁) = true
Hwfl₂: wf (map nh_patt l₂) = true
H: Γ
⊢i foldr patt_imp (foldr patt_and x xs)
     (map nh_patt l₁ ++ r :: map nh_patt l₂)
using i
Γ ⊢i (foldr patt_and x xs ---> g') ---> ?h
using BasicReasoning
    apply lhs_and_to_imp.
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
Hwf1: well_formed g'
Hwf2: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wfr: well_formed r
wffa: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
H0: well_formed x
H1: wf xs
Hwfl₁: wf (map nh_patt l₁) = true
Hwfl₂: wf (map nh_patt l₂) = true
H: Γ
⊢i foldr patt_imp (foldr patt_and x xs)
     (map nh_patt l₁ ++ r :: map nh_patt l₂)
using i
well_formed g'
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
Hwf1: well_formed g'
Hwf2: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wfr: well_formed r
wffa: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
H0: well_formed x
H1: wf xs
Hwfl₁: wf (map nh_patt l₁) = true
Hwfl₂: wf (map nh_patt l₂) = true
H: Γ
⊢i foldr patt_imp (foldr patt_and x xs)
     (map nh_patt l₁ ++ r :: map nh_patt l₂)
using i
well_formed x
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
Hwf1: well_formed g'
Hwf2: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wfr: well_formed r
wffa: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
H0: well_formed x
H1: wf xs
Hwfl₁: wf (map nh_patt l₁) = true
Hwfl₂: wf (map nh_patt l₂) = true
H: Γ
⊢i foldr patt_imp (foldr patt_and x xs)
     (map nh_patt l₁ ++ r :: map nh_patt l₂)
using i
wf xs
    1-3: wf_auto2.
  }
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
Hwf1: well_formed g'
Hwf2: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wfr: well_formed r
wffa: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
H0: well_formed x
H1: wf xs
Hwfl₁: wf (map nh_patt l₁) = true
Hwfl₂: wf (map nh_patt l₂) = true
H: Γ
⊢i foldr patt_imp (foldr patt_and x xs)
     (map nh_patt l₁ ++ r :: map nh_patt l₂)
using i
wf (map nh_patt l₁)
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
Hwf1: well_formed g'
Hwf2: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wfr: well_formed r
wffa: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
H0: well_formed x
H1: wf xs
Hwfl₁: wf (map nh_patt l₁) = true
Hwfl₂: wf (map nh_patt l₂) = true
H: Γ
⊢i foldr patt_imp (foldr patt_and x xs)
     (map nh_patt l₁ ++ r :: map nh_patt l₂)
using i
wf (map nh_patt l₂)
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
Hwf1: well_formed g'
Hwf2: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wfr: well_formed r
wffa: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
H0: well_formed x
H1: wf xs
Hwfl₁: wf (map nh_patt l₁) = true
Hwfl₂: wf (map nh_patt l₂) = true
H: Γ
⊢i foldr patt_imp (foldr patt_and x xs)
     (map nh_patt l₁ ++ r :: map nh_patt l₂)
using i
well_formed (foldr patt_imp g' (x :: xs))
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
Hwf1: well_formed g'
Hwf2: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wfr: well_formed r
wffa: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
H0: well_formed x
H1: wf xs
Hwfl₁: wf (map nh_patt l₁) = true
Hwfl₂: wf (map nh_patt l₂) = true
H: Γ
⊢i foldr patt_imp (foldr patt_and x xs)
     (map nh_patt l₁ ++ r :: map nh_patt l₂)
using i
well_formed (foldr patt_and x xs ---> g')
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
Hwf1: well_formed g'
Hwf2: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wfr: well_formed r
wffa: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
H0: well_formed x
H1: wf xs
Hwfl₁: wf (map nh_patt l₁) = true
Hwfl₂: wf (map nh_patt l₂) = true
H: Γ
⊢i foldr patt_imp (foldr patt_and x xs)
     (map nh_patt l₁ ++ r :: map nh_patt l₂)
using i
well_formed (foldr patt_and x xs)
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
Hwf1: well_formed g'
Hwf2: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wfr: well_formed r
wffa: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
H0: well_formed x
H1: wf xs
Hwfl₁: wf (map nh_patt l₁) = true
Hwfl₂: wf (map nh_patt l₂) = true
H: Γ
⊢i foldr patt_imp (foldr patt_and x xs)
     (map nh_patt l₁ ++ r :: map nh_patt l₂)
using i
Γ
⊢i foldr patt_imp (foldr patt_and x xs)
     (map nh_patt l₁ ++
      foldr patt_imp g' (x :: xs) :: map nh_patt l₂)
using i
  1-5: wf_auto2.
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
Hwf1: well_formed g'
Hwf2: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wfr: well_formed r
wffa: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
H0: well_formed x
H1: wf xs
Hwfl₁: wf (map nh_patt l₁) = true
Hwfl₂: wf (map nh_patt l₂) = true
H: Γ
⊢i foldr patt_imp (foldr patt_and x xs)
     (map nh_patt l₁ ++ r :: map nh_patt l₂)
using i
Γ
⊢i foldr patt_imp (foldr patt_and x xs)
     (map nh_patt l₁ ++
      foldr patt_imp g' (x :: xs) :: map nh_patt l₂)
using i

  rewrite irs_pf in H.
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
Hwf1: well_formed g'
Hwf2: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wfr: well_formed r
wffa: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
H0: well_formed x
H1: wf xs
Hwfl₁: wf (map nh_patt l₁) = true
Hwfl₂: wf (map nh_patt l₂) = true
H: Γ
⊢i foldr patt_imp (foldr patt_and x xs)
     (map nh_patt l₁ ++
      foldr patt_imp g' (x :: xs)
      :: map nh_patt l₂) using i
Γ
⊢i foldr patt_imp (foldr patt_and x xs)
     (map nh_patt l₁ ++
      foldr patt_imp g' (x :: xs) :: map nh_patt l₂)
using i
  exact H.
Defined.

Lemma MLGoal_weakenConclusionGen {Σ : Signature} Γ l₁ l₂ name g' i
    (x : Pattern) (xs : list Pattern)
  :
  forall (r : ImpReshapeS g' (x::xs)),
  mkMLGoal Σ Γ (l₁ ++ (mkNH _ name ((untagPattern (irs_flattened _ _ r)))) :: l₂)
    (
      match (rev xs) with
      | [] => x
      | yk::ys => (foldr (patt_and) yk (x::(rev ys)))
      end
    )
    i ->
  mkMLGoal Σ Γ (l₁ ++ (mkNH _ name ((untagPattern (irs_flattened _ _ r)))) :: l₂) g' i.
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
∀ r : ImpReshapeS g' (x :: xs),
  Γ Ⱶ
  l₁ ++ (name ∶ r) :: l₂--------------------------------------
  match rev xs with
  | [] => x
  | yk :: ys => foldr patt_and yk (x :: rev ys)
  end
  using i
  
  → Γ Ⱶ
  l₁ ++ (name ∶ r) :: l₂--------------------------------------
  g'
  using i
  
Proof.
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
∀ r : ImpReshapeS g' (x :: xs),
  Γ Ⱶ
  l₁ ++ (name ∶ r) :: l₂--------------------------------------
  match rev xs with
  | [] => x
  | yk :: ys => foldr patt_and yk (x :: rev ys)
  end
  using i
  
  → Γ Ⱶ
  l₁ ++ (name ∶ r) :: l₂--------------------------------------
  g'
  using i
  
  intros r H.
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
H: Γ Ⱶ
l₁ ++ (name ∶ r) :: l₂--------------------------------------
match rev xs with
| [] => x
| yk :: ys => foldr patt_and yk (x :: rev ys)
end
using i

Γ Ⱶ
l₁ ++ (name ∶ r) :: l₂--------------------------------------
g'
using i

  apply MLGoal_weakenConclusionGen'.
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
H: Γ Ⱶ
l₁ ++ (name ∶ r) :: l₂--------------------------------------
match rev xs with
| [] => x
| yk :: ys => foldr patt_and yk (x :: rev ys)
end
using i

Γ Ⱶ
l₁ ++ (name ∶ r) :: l₂--------------------------------------
foldr patt_and x xs
using i

  intros wf1 wf2.
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
H: Γ Ⱶ
l₁ ++ (name ∶ r) :: l₂--------------------------------------
match rev xs with
| [] => x
| yk :: ys => foldr patt_and yk (x :: rev ys)
end
using i

wf1: well_formed
  (mlConclusion
     (Γ Ⱶ
      l₁ ++ (name ∶ r) :: l₂--------------------------------------
      foldr patt_and x xs
      using i
      ))
wf2: wf
  (patterns_of
     (mlHypotheses
        (Γ Ⱶ
         l₁ ++ (name ∶ r) :: l₂--------------------------------------
         foldr patt_and x xs
         using i
         )))
mlTheory
  (Γ Ⱶ
   l₁ ++ (name ∶ r) :: l₂--------------------------------------
   foldr patt_and x xs
   using i
   )
⊢i foldr patt_imp
     (mlConclusion
        (Γ Ⱶ
         l₁ ++ (name ∶ r) :: l₂--------------------------------------
         foldr patt_and x xs
         using i
         ))
     (patterns_of
        (mlHypotheses
           (Γ Ⱶ
            l₁ ++ (name ∶ r) :: l₂--------------------------------------
            foldr patt_and x xs
            using i
            )))
using mlInfo
        (Γ Ⱶ
         l₁ ++ (name ∶ r) :: l₂--------------------------------------
         foldr patt_and x xs
         using i
         ) cbn.
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
H: Γ Ⱶ
l₁ ++ (name ∶ r) :: l₂--------------------------------------
match rev xs with
| [] => x
| yk :: ys => foldr patt_and yk (x :: rev ys)
end
using i

wf1: well_formed
  (mlConclusion
     (Γ Ⱶ
      l₁ ++ (name ∶ r) :: l₂--------------------------------------
      foldr patt_and x xs
      using i
      ))
wf2: wf
  (patterns_of
     (mlHypotheses
        (Γ Ⱶ
         l₁ ++ (name ∶ r) :: l₂--------------------------------------
         foldr patt_and x xs
         using i
         )))
Γ
⊢i foldr patt_imp (foldr patt_and x xs)
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)) using i

  feed specialize H.
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
H: Γ Ⱶ
l₁ ++ (name ∶ r) :: l₂--------------------------------------
match rev xs with
| [] => x
| yk :: ys => foldr patt_and yk (x :: rev ys)
end
using i

wf1: well_formed
  (mlConclusion
     (Γ Ⱶ
      l₁ ++ (name ∶ r) :: l₂--------------------------------------
      foldr patt_and x xs
      using i
      ))
wf2: wf
  (patterns_of
     (mlHypotheses
        (Γ Ⱶ
         l₁ ++ (name ∶ r) :: l₂--------------------------------------
         foldr patt_and x xs
         using i
         )))
well_formed
  (mlConclusion
     (Γ Ⱶ
      l₁ ++ (name ∶ r) :: l₂--------------------------------------
      match rev xs with
      | [] => x
      | yk :: ys => foldr patt_and yk (x :: rev ys)
      end
      using i
      ))
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
H: Γ Ⱶ
l₁ ++ (name ∶ r) :: l₂--------------------------------------
match rev xs with
| [] => x
| yk :: ys => foldr patt_and yk (x :: rev ys)
end
using i

wf1: well_formed
  (mlConclusion
     (Γ Ⱶ
      l₁ ++ (name ∶ r) :: l₂--------------------------------------
      foldr patt_and x xs
      using i
      ))
wf2: wf
  (patterns_of
     (mlHypotheses
        (Γ Ⱶ
         l₁ ++ (name ∶ r) :: l₂--------------------------------------
         foldr patt_and x xs
         using i
         )))
wf
  (patterns_of
     (mlHypotheses
        (Γ Ⱶ
         l₁ ++ (name ∶ r) :: l₂--------------------------------------
         match rev xs with
         | [] => x
         | yk :: ys => foldr patt_and yk (x :: rev ys)
         end
         using i
         )))
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
H: mlTheory
  (Γ Ⱶ
   l₁ ++ (name ∶ r) :: l₂--------------------------------------
   match rev xs with
   | [] => x
   | yk :: ys => foldr patt_and yk (x :: rev ys)
   end
   using i
   )
⊢i foldr patt_imp
     (mlConclusion
        (Γ Ⱶ
         l₁ ++ (name ∶ r) :: l₂--------------------------------------
         match rev xs with
         | [] => x
         | yk :: ys =>
             foldr patt_and yk (x :: rev ys)
         end
         using i
         ))
     (patterns_of
        (mlHypotheses
           (Γ Ⱶ
            l₁ ++ (name ∶ r) :: l₂--------------------------------------
            match rev xs with
            | [] => x
            | yk :: ys =>
                foldr patt_and yk (x :: rev ys)
            end
            using i
            )))
using mlInfo
        (Γ Ⱶ
         l₁ ++ (name ∶ r) :: l₂--------------------------------------
         match rev xs with
         | [] => x
         | yk :: ys =>
             foldr patt_and yk (x :: rev ys)
         end
         using i
         )
wf1: well_formed
  (mlConclusion
     (Γ Ⱶ
      l₁ ++ (name ∶ r) :: l₂--------------------------------------
      foldr patt_and x xs
      using i
      ))
wf2: wf
  (patterns_of
     (mlHypotheses
        (Γ Ⱶ
         l₁ ++ (name ∶ r) :: l₂--------------------------------------
         foldr patt_and x xs
         using i
         )))
Γ
⊢i foldr patt_imp (foldr patt_and x xs)
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)) using i
  {
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
H: Γ Ⱶ
l₁ ++ (name ∶ r) :: l₂--------------------------------------
match rev xs with
| [] => x
| yk :: ys => foldr patt_and yk (x :: rev ys)
end
using i

wf1: well_formed
  (mlConclusion
     (Γ Ⱶ
      l₁ ++ (name ∶ r) :: l₂--------------------------------------
      foldr patt_and x xs
      using i
      ))
wf2: wf
  (patterns_of
     (mlHypotheses
        (Γ Ⱶ
         l₁ ++ (name ∶ r) :: l₂--------------------------------------
         foldr patt_and x xs
         using i
         )))
well_formed
  (mlConclusion
     (Γ Ⱶ
      l₁ ++ (name ∶ r) :: l₂--------------------------------------
      match rev xs with
      | [] => x
      | yk :: ys => foldr patt_and yk (x :: rev ys)
      end
      using i
      ))
    cbn.
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
H: Γ Ⱶ
l₁ ++ (name ∶ r) :: l₂--------------------------------------
match rev xs with
| [] => x
| yk :: ys => foldr patt_and yk (x :: rev ys)
end
using i

wf1: well_formed
  (mlConclusion
     (Γ Ⱶ
      l₁ ++ (name ∶ r) :: l₂--------------------------------------
      foldr patt_and x xs
      using i
      ))
wf2: wf
  (patterns_of
     (mlHypotheses
        (Γ Ⱶ
         l₁ ++ (name ∶ r) :: l₂--------------------------------------
         foldr patt_and x xs
         using i
         )))
well_formed
  match rev xs with
  | [] => x
  | yk :: ys => x and foldr patt_and yk (rev ys)
  end clear H.
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
wf1: well_formed
  (mlConclusion
     (Γ Ⱶ
      l₁ ++ (name ∶ r) :: l₂--------------------------------------
      foldr patt_and x xs
      using i
      ))
wf2: wf
  (patterns_of
     (mlHypotheses
        (Γ Ⱶ
         l₁ ++ (name ∶ r) :: l₂--------------------------------------
         foldr patt_and x xs
         using i
         )))
well_formed
  match rev xs with
  | [] => x
  | yk :: ys => x and foldr patt_and yk (rev ys)
  end
    destruct (rev xs) eqn:Heqxs.
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
wf1: well_formed
  (mlConclusion
     (Γ Ⱶ
      l₁ ++ (name ∶ r) :: l₂--------------------------------------
      foldr patt_and x xs
      using i
      ))
wf2: wf
  (patterns_of
     (mlHypotheses
        (Γ Ⱶ
         l₁ ++ (name ∶ r) :: l₂--------------------------------------
         foldr patt_and x xs
         using i
         )))
Heqxs: rev xs = []
well_formed x
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
wf1: well_formed
  (mlConclusion
     (Γ Ⱶ
      l₁ ++ (name ∶ r) :: l₂--------------------------------------
      foldr patt_and x xs
      using i
      ))
wf2: wf
  (patterns_of
     (mlHypotheses
        (Γ Ⱶ
         l₁ ++ (name ∶ r) :: l₂--------------------------------------
         foldr patt_and x xs
         using i
         )))
p: Pattern
l: list Pattern
Heqxs: rev xs = p :: l
well_formed (x and foldr patt_and p (rev l))
    {
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
wf1: well_formed
  (mlConclusion
     (Γ Ⱶ
      l₁ ++ (name ∶ r) :: l₂--------------------------------------
      foldr patt_and x xs
      using i
      ))
wf2: wf
  (patterns_of
     (mlHypotheses
        (Γ Ⱶ
         l₁ ++ (name ∶ r) :: l₂--------------------------------------
         foldr patt_and x xs
         using i
         )))
Heqxs: rev xs = []
well_formed x
      wf_auto2.
    }
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
wf1: well_formed
  (mlConclusion
     (Γ Ⱶ
      l₁ ++ (name ∶ r) :: l₂--------------------------------------
      foldr patt_and x xs
      using i
      ))
wf2: wf
  (patterns_of
     (mlHypotheses
        (Γ Ⱶ
         l₁ ++ (name ∶ r) :: l₂--------------------------------------
         foldr patt_and x xs
         using i
         )))
p: Pattern
l: list Pattern
Heqxs: rev xs = p :: l
well_formed (x and foldr patt_and p (rev l))
    {
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
wf1: well_formed
  (mlConclusion
     (Γ Ⱶ
      l₁ ++ (name ∶ r) :: l₂--------------------------------------
      foldr patt_and x xs
      using i
      ))
wf2: wf
  (patterns_of
     (mlHypotheses
        (Γ Ⱶ
         l₁ ++ (name ∶ r) :: l₂--------------------------------------
         foldr patt_and x xs
         using i
         )))
p: Pattern
l: list Pattern
Heqxs: rev xs = p :: l
well_formed (x and foldr patt_and p (rev l))
      apply (f_equal (@rev Pattern)) in Heqxs.
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
wf1: well_formed
  (mlConclusion
     (Γ Ⱶ
      l₁ ++ (name ∶ r) :: l₂--------------------------------------
      foldr patt_and x xs
      using i
      ))
wf2: wf
  (patterns_of
     (mlHypotheses
        (Γ Ⱶ
         l₁ ++ (name ∶ r) :: l₂--------------------------------------
         foldr patt_and x xs
         using i
         )))
p: Pattern
l: list Pattern
Heqxs: rev (rev xs) = rev (p :: l)
well_formed (x and foldr patt_and p (rev l))
      rewrite rev_involutive in Heqxs.
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
wf1: well_formed
  (mlConclusion
     (Γ Ⱶ
      l₁ ++ (name ∶ r) :: l₂--------------------------------------
      foldr patt_and x xs
      using i
      ))
wf2: wf
  (patterns_of
     (mlHypotheses
        (Γ Ⱶ
         l₁ ++ (name ∶ r) :: l₂--------------------------------------
         foldr patt_and x xs
         using i
         )))
p: Pattern
l: list Pattern
Heqxs: xs = rev (p :: l)
well_formed (x and foldr patt_and p (rev l))
      simpl in Heqxs.
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
wf1: well_formed
  (mlConclusion
     (Γ Ⱶ
      l₁ ++ (name ∶ r) :: l₂--------------------------------------
      foldr patt_and x xs
      using i
      ))
wf2: wf
  (patterns_of
     (mlHypotheses
        (Γ Ⱶ
         l₁ ++ (name ∶ r) :: l₂--------------------------------------
         foldr patt_and x xs
         using i
         )))
p: Pattern
l: list Pattern
Heqxs: xs = rev l ++ [p]
well_formed (x and foldr patt_and p (rev l))
      subst xs.
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x, p: Pattern
l: list Pattern
r: ImpReshapeS g' (x :: rev l ++ [p])
wf2: wf
  (patterns_of
     (mlHypotheses
        (Γ Ⱶ
         l₁ ++ (name ∶ r) :: l₂--------------------------------------
         foldr patt_and x (rev l ++ [p])
         using i
         )))
wf1: well_formed
  (mlConclusion
     (Γ Ⱶ
      l₁ ++ (name ∶ r) :: l₂--------------------------------------
      foldr patt_and x (rev l ++ [p])
      using i
      ))
well_formed (x and foldr patt_and p (rev l))
      wf_auto2.
    }
  }
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
H: Γ Ⱶ
l₁ ++ (name ∶ r) :: l₂--------------------------------------
match rev xs with
| [] => x
| yk :: ys => foldr patt_and yk (x :: rev ys)
end
using i

wf1: well_formed
  (mlConclusion
     (Γ Ⱶ
      l₁ ++ (name ∶ r) :: l₂--------------------------------------
      foldr patt_and x xs
      using i
      ))
wf2: wf
  (patterns_of
     (mlHypotheses
        (Γ Ⱶ
         l₁ ++ (name ∶ r) :: l₂--------------------------------------
         foldr patt_and x xs
         using i
         )))
wf
  (patterns_of
     (mlHypotheses
        (Γ Ⱶ
         l₁ ++ (name ∶ r) :: l₂--------------------------------------
         match rev xs with
         | [] => x
         | yk :: ys => foldr patt_and yk (x :: rev ys)
         end
         using i
         )))
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
H: mlTheory
  (Γ Ⱶ
   l₁ ++ (name ∶ r) :: l₂--------------------------------------
   match rev xs with
   | [] => x
   | yk :: ys => foldr patt_and yk (x :: rev ys)
   end
   using i
   )
⊢i foldr patt_imp
     (mlConclusion
        (Γ Ⱶ
         l₁ ++ (name ∶ r) :: l₂--------------------------------------
         match rev xs with
         | [] => x
         | yk :: ys =>
             foldr patt_and yk (x :: rev ys)
         end
         using i
         ))
     (patterns_of
        (mlHypotheses
           (Γ Ⱶ
            l₁ ++ (name ∶ r) :: l₂--------------------------------------
            match rev xs with
            | [] => x
            | yk :: ys =>
                foldr patt_and yk (x :: rev ys)
            end
            using i
            )))
using mlInfo
        (Γ Ⱶ
         l₁ ++ (name ∶ r) :: l₂--------------------------------------
         match rev xs with
         | [] => x
         | yk :: ys =>
             foldr patt_and yk (x :: rev ys)
         end
         using i
         )
wf1: well_formed
  (mlConclusion
     (Γ Ⱶ
      l₁ ++ (name ∶ r) :: l₂--------------------------------------
      foldr patt_and x xs
      using i
      ))
wf2: wf
  (patterns_of
     (mlHypotheses
        (Γ Ⱶ
         l₁ ++ (name ∶ r) :: l₂--------------------------------------
         foldr patt_and x xs
         using i
         )))
Γ
⊢i foldr patt_imp (foldr patt_and x xs)
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)) using i
  {
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
H: Γ Ⱶ
l₁ ++ (name ∶ r) :: l₂--------------------------------------
match rev xs with
| [] => x
| yk :: ys => foldr patt_and yk (x :: rev ys)
end
using i

wf1: well_formed
  (mlConclusion
     (Γ Ⱶ
      l₁ ++ (name ∶ r) :: l₂--------------------------------------
      foldr patt_and x xs
      using i
      ))
wf2: wf
  (patterns_of
     (mlHypotheses
        (Γ Ⱶ
         l₁ ++ (name ∶ r) :: l₂--------------------------------------
         foldr patt_and x xs
         using i
         )))
wf
  (patterns_of
     (mlHypotheses
        (Γ Ⱶ
         l₁ ++ (name ∶ r) :: l₂--------------------------------------
         match rev xs with
         | [] => x
         | yk :: ys => foldr patt_and yk (x :: rev ys)
         end
         using i
         )))
    cbn.
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
H: Γ Ⱶ
l₁ ++ (name ∶ r) :: l₂--------------------------------------
match rev xs with
| [] => x
| yk :: ys => foldr patt_and yk (x :: rev ys)
end
using i

wf1: well_formed
  (mlConclusion
     (Γ Ⱶ
      l₁ ++ (name ∶ r) :: l₂--------------------------------------
      foldr patt_and x xs
      using i
      ))
wf2: wf
  (patterns_of
     (mlHypotheses
        (Γ Ⱶ
         l₁ ++ (name ∶ r) :: l₂--------------------------------------
         foldr patt_and x xs
         using i
         )))
foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂))) clear H.
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
wf1: well_formed
  (mlConclusion
     (Γ Ⱶ
      l₁ ++ (name ∶ r) :: l₂--------------------------------------
      foldr patt_and x xs
      using i
      ))
wf2: wf
  (patterns_of
     (mlHypotheses
        (Γ Ⱶ
         l₁ ++ (name ∶ r) :: l₂--------------------------------------
         foldr patt_and x xs
         using i
         )))
foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂))) cbn in *.
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
wf1: well_formed (foldr patt_and x xs)
wf2: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
    wf_auto2.
  }
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
H: mlTheory
  (Γ Ⱶ
   l₁ ++ (name ∶ r) :: l₂--------------------------------------
   match rev xs with
   | [] => x
   | yk :: ys => foldr patt_and yk (x :: rev ys)
   end
   using i
   )
⊢i foldr patt_imp
     (mlConclusion
        (Γ Ⱶ
         l₁ ++ (name ∶ r) :: l₂--------------------------------------
         match rev xs with
         | [] => x
         | yk :: ys =>
             foldr patt_and yk (x :: rev ys)
         end
         using i
         ))
     (patterns_of
        (mlHypotheses
           (Γ Ⱶ
            l₁ ++ (name ∶ r) :: l₂--------------------------------------
            match rev xs with
            | [] => x
            | yk :: ys =>
                foldr patt_and yk (x :: rev ys)
            end
            using i
            )))
using mlInfo
        (Γ Ⱶ
         l₁ ++ (name ∶ r) :: l₂--------------------------------------
         match rev xs with
         | [] => x
         | yk :: ys =>
             foldr patt_and yk (x :: rev ys)
         end
         using i
         )
wf1: well_formed
  (mlConclusion
     (Γ Ⱶ
      l₁ ++ (name ∶ r) :: l₂--------------------------------------
      foldr patt_and x xs
      using i
      ))
wf2: wf
  (patterns_of
     (mlHypotheses
        (Γ Ⱶ
         l₁ ++ (name ∶ r) :: l₂--------------------------------------
         foldr patt_and x xs
         using i
         )))
Γ
⊢i foldr patt_imp (foldr patt_and x xs)
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)) using i
  cbn in *.
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
H: Γ
⊢i foldr patt_imp
     match rev xs with
     | [] => x
     | yk :: ys =>
         x and foldr patt_and yk (rev ys)
     end (map nh_patt (l₁ ++ (name ∶ r) :: l₂))
using i
wf1: well_formed (foldr patt_and x xs)
wf2: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
Γ
⊢i foldr patt_imp (foldr patt_and x xs)
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)) using i
  destruct (rev xs) eqn:Heqxs.
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
Heqxs: rev xs = []
H: Γ
⊢i foldr patt_imp x
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂))
using i
wf1: well_formed (foldr patt_and x xs)
wf2: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
Γ
⊢i foldr patt_imp (foldr patt_and x xs)
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)) using i
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
p: Pattern
l: list Pattern
Heqxs: rev xs = p :: l
H: Γ
⊢i foldr patt_imp (x and foldr patt_and p (rev l))
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂))
using i
wf1: well_formed (foldr patt_and x xs)
wf2: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
Γ
⊢i foldr patt_imp (foldr patt_and x xs)
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)) using i
  {
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
Heqxs: rev xs = []
H: Γ
⊢i foldr patt_imp x
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂))
using i
wf1: well_formed (foldr patt_and x xs)
wf2: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
Γ
⊢i foldr patt_imp (foldr patt_and x xs)
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)) using i
    apply (f_equal (@rev Pattern)) in Heqxs.
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
Heqxs: rev (rev xs) = rev []
H: Γ
⊢i foldr patt_imp x
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂))
using i
wf1: well_formed (foldr patt_and x xs)
wf2: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
Γ
⊢i foldr patt_imp (foldr patt_and x xs)
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)) using i
    rewrite rev_involutive in Heqxs.
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
H: Γ
⊢i foldr patt_imp x
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂))
using i
wf1: well_formed (foldr patt_and x xs)
wf2: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
Heqxs: xs = rev []
Γ
⊢i foldr patt_imp (foldr patt_and x xs)
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)) using i
    simpl in Heqxs.
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
H: Γ
⊢i foldr patt_imp x
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂))
using i
wf1: well_formed (foldr patt_and x xs)
wf2: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
Heqxs: xs = []
Γ
⊢i foldr patt_imp (foldr patt_and x xs)
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)) using i
    subst xs.
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
r: ImpReshapeS g' [x]
wf2: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wf1: well_formed (foldr patt_and x [])
H: Γ
⊢i foldr patt_imp x
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂))
using i
Γ
⊢i foldr patt_imp (foldr patt_and x [])
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)) using i
    cbn in *.
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
r: ImpReshapeS g' [x]
wf2: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wf1: well_formed x
H: Γ
⊢i foldr patt_imp x
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂))
using i
Γ
⊢i foldr patt_imp x
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)) using i
    exact H.
  }
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
p: Pattern
l: list Pattern
Heqxs: rev xs = p :: l
H: Γ
⊢i foldr patt_imp (x and foldr patt_and p (rev l))
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂))
using i
wf1: well_formed (foldr patt_and x xs)
wf2: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
Γ
⊢i foldr patt_imp (foldr patt_and x xs)
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)) using i
  {
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
p: Pattern
l: list Pattern
Heqxs: rev xs = p :: l
H: Γ
⊢i foldr patt_imp (x and foldr patt_and p (rev l))
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂))
using i
wf1: well_formed (foldr patt_and x xs)
wf2: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
Γ
⊢i foldr patt_imp (foldr patt_and x xs)
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)) using i
    apply (f_equal (@rev Pattern)) in Heqxs.
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
p: Pattern
l: list Pattern
Heqxs: rev (rev xs) = rev (p :: l)
H: Γ
⊢i foldr patt_imp (x and foldr patt_and p (rev l))
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂))
using i
wf1: well_formed (foldr patt_and x xs)
wf2: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
Γ
⊢i foldr patt_imp (foldr patt_and x xs)
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)) using i
    rewrite rev_involutive in Heqxs.
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
p: Pattern
l: list Pattern
H: Γ
⊢i foldr patt_imp (x and foldr patt_and p (rev l))
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂))
using i
wf1: well_formed (foldr patt_and x xs)
wf2: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
Heqxs: xs = rev (p :: l)
Γ
⊢i foldr patt_imp (foldr patt_and x xs)
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)) using i
    simpl in Heqxs.
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
p: Pattern
l: list Pattern
H: Γ
⊢i foldr patt_imp (x and foldr patt_and p (rev l))
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂))
using i
wf1: well_formed (foldr patt_and x xs)
wf2: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
Heqxs: xs = rev l ++ [p]
Γ
⊢i foldr patt_imp (foldr patt_and x xs)
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)) using i
    subst xs.
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x, p: Pattern
l: list Pattern
r: ImpReshapeS g' (x :: rev l ++ [p])
wf2: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wf1: well_formed (foldr patt_and x (rev l ++ [p]))
H: Γ
⊢i foldr patt_imp (x and foldr patt_and p (rev l))
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂))
using i
Γ
⊢i foldr patt_imp (foldr patt_and x (rev l ++ [p]))
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)) using i

    eapply prf_weaken_conclusion_iter_meta_meta.
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x, p: Pattern
l: list Pattern
r: ImpReshapeS g' (x :: rev l ++ [p])
wf2: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wf1: well_formed (foldr patt_and x (rev l ++ [p]))
H: Γ
⊢i foldr patt_imp (x and foldr patt_and p (rev l))
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂))
using i
wf (map nh_patt (l₁ ++ (name ∶ r) :: l₂))
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x, p: Pattern
l: list Pattern
r: ImpReshapeS g' (x :: rev l ++ [p])
wf2: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wf1: well_formed (foldr patt_and x (rev l ++ [p]))
H: Γ
⊢i foldr patt_imp (x and foldr patt_and p (rev l))
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂))
using i
well_formed ?g
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x, p: Pattern
l: list Pattern
r: ImpReshapeS g' (x :: rev l ++ [p])
wf2: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wf1: well_formed (foldr patt_and x (rev l ++ [p]))
H: Γ
⊢i foldr patt_imp (x and foldr patt_and p (rev l))
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂))
using i
well_formed (foldr patt_and x (rev l ++ [p]))
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x, p: Pattern
l: list Pattern
r: ImpReshapeS g' (x :: rev l ++ [p])
wf2: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wf1: well_formed (foldr patt_and x (rev l ++ [p]))
H: Γ
⊢i foldr patt_imp (x and foldr patt_and p (rev l))
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂))
using i
Γ ⊢i ?g ---> foldr patt_and x (rev l ++ [p]) using i
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x, p: Pattern
l: list Pattern
r: ImpReshapeS g' (x :: rev l ++ [p])
wf2: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wf1: well_formed (foldr patt_and x (rev l ++ [p]))
H: Γ
⊢i foldr patt_imp (x and foldr patt_and p (rev l))
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂))
using i
Γ
⊢i foldr patt_imp ?g
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)) using i
    5: apply H.
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x, p: Pattern
l: list Pattern
r: ImpReshapeS g' (x :: rev l ++ [p])
wf2: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wf1: well_formed (foldr patt_and x (rev l ++ [p]))
H: Γ
⊢i foldr patt_imp (x and foldr patt_and p (rev l))
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂))
using i
wf (map nh_patt (l₁ ++ (name ∶ r) :: l₂))
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x, p: Pattern
l: list Pattern
r: ImpReshapeS g' (x :: rev l ++ [p])
wf2: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wf1: well_formed (foldr patt_and x (rev l ++ [p]))
H: Γ
⊢i foldr patt_imp (x and foldr patt_and p (rev l))
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂))
using i
well_formed (x and foldr patt_and p (rev l))
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x, p: Pattern
l: list Pattern
r: ImpReshapeS g' (x :: rev l ++ [p])
wf2: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wf1: well_formed (foldr patt_and x (rev l ++ [p]))
H: Γ
⊢i foldr patt_imp (x and foldr patt_and p (rev l))
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂))
using i
well_formed (foldr patt_and x (rev l ++ [p]))
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x, p: Pattern
l: list Pattern
r: ImpReshapeS g' (x :: rev l ++ [p])
wf2: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wf1: well_formed (foldr patt_and x (rev l ++ [p]))
H: Γ
⊢i foldr patt_imp (x and foldr patt_and p (rev l))
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂))
using i
Γ
⊢i x and foldr patt_and p (rev l) --->
   foldr patt_and x (rev l ++ [p]) using i
    4: {
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x, p: Pattern
l: list Pattern
r: ImpReshapeS g' (x :: rev l ++ [p])
wf2: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wf1: well_formed (foldr patt_and x (rev l ++ [p]))
H: Γ
⊢i foldr patt_imp (x and foldr patt_and p (rev l))
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂))
using i
Γ
⊢i x and foldr patt_and p (rev l) --->
   foldr patt_and x (rev l ++ [p]) using i
      rewrite foldr_app.
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x, p: Pattern
l: list Pattern
r: ImpReshapeS g' (x :: rev l ++ [p])
wf2: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wf1: well_formed (foldr patt_and x (rev l ++ [p]))
H: Γ
⊢i foldr patt_imp (x and foldr patt_and p (rev l))
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂))
using i
Γ
⊢i x and foldr patt_and p (rev l) --->
   foldr patt_and (foldr patt_and x [p]) (rev l)
using i cbn.
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x, p: Pattern
l: list Pattern
r: ImpReshapeS g' (x :: rev l ++ [p])
wf2: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wf1: well_formed (foldr patt_and x (rev l ++ [p]))
H: Γ
⊢i foldr patt_imp (x and foldr patt_and p (rev l))
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂))
using i
Γ
⊢i x and foldr patt_and p (rev l) --->
   foldr patt_and (p and x) (rev l) using i
      toMLGoal.
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x, p: Pattern
l: list Pattern
r: ImpReshapeS g' (x :: rev l ++ [p])
wf2: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wf1: well_formed (foldr patt_and x (rev l ++ [p]))
H: Γ
⊢i foldr patt_imp (x and foldr patt_and p (rev l))
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂))
using i
well_formed
  (x and foldr patt_and p (rev l) --->
   foldr patt_and (p and x) (rev l))
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x, p: Pattern
l: list Pattern
r: ImpReshapeS g' (x :: rev l ++ [p])
wf2: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wf1: well_formed (foldr patt_and x (rev l ++ [p]))
H: Γ
⊢i foldr patt_imp (x and foldr patt_and p (rev l))
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂))
using i
Γ Ⱶ
x and foldr patt_and p (rev l) --->
foldr patt_and (p and x) (rev l)
using i

      {
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x, p: Pattern
l: list Pattern
r: ImpReshapeS g' (x :: rev l ++ [p])
wf2: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wf1: well_formed (foldr patt_and x (rev l ++ [p]))
H: Γ
⊢i foldr patt_imp (x and foldr patt_and p (rev l))
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂))
using i
well_formed
  (x and foldr patt_and p (rev l) --->
   foldr patt_and (p and x) (rev l))
        wf_auto2.
      }
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x, p: Pattern
l: list Pattern
r: ImpReshapeS g' (x :: rev l ++ [p])
wf2: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wf1: well_formed (foldr patt_and x (rev l ++ [p]))
H: Γ
⊢i foldr patt_imp (x and foldr patt_and p (rev l))
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂))
using i
Γ Ⱶ
x and foldr patt_and p (rev l) --->
foldr patt_and (p and x) (rev l)
using i

      mlIntro "H1".
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x, p: Pattern
l: list Pattern
r: ImpReshapeS g' (x :: rev l ++ [p])
wf2: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wf1: well_formed (foldr patt_and x (rev l ++ [p]))
H: Γ
⊢i foldr patt_imp (x and foldr patt_and p (rev l))
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂))
using i
Γ Ⱶ
"H1" ∶ x and foldr patt_and p (rev l),
--------------------------------------
foldr patt_and (p and x) (rev l)
using i

      mlDestructAnd "H1" as "Hx" "Hf".
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x, p: Pattern
l: list Pattern
r: ImpReshapeS g' (x :: rev l ++ [p])
wf2: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wf1: well_formed (foldr patt_and x (rev l ++ [p]))
H: Γ
⊢i foldr patt_imp (x and foldr patt_and p (rev l))
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂))
using i
Γ Ⱶ
"Hx" ∶ x,
"Hf" ∶ foldr patt_and p (rev l),
--------------------------------------
foldr patt_and (p and x) (rev l)
using i

      useBasicReasoning.
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x, p: Pattern
l: list Pattern
r: ImpReshapeS g' (x :: rev l ++ [p])
wf2: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wf1: well_formed (foldr patt_and x (rev l ++ [p]))
H: Γ
⊢i foldr patt_imp (x and foldr patt_and p (rev l))
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂))
using i
Γ Ⱶ
"Hx" ∶ x,
"Hf" ∶ foldr patt_and p (rev l),
--------------------------------------
foldr patt_and (p and x) (rev l)
using BasicReasoning

      mlAdd (foldr_and_weaken_last Γ p (p and x) (rev l) ltac:(wf_auto2) ltac:(wf_auto2) ltac:(wf_auto2)) as "Hw".
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x, p: Pattern
l: list Pattern
r: ImpReshapeS g' (x :: rev l ++ [p])
wf2: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wf1: well_formed (foldr patt_and x (rev l ++ [p]))
H: Γ
⊢i foldr patt_imp (x and foldr patt_and p (rev l))
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂))
using i
Γ Ⱶ
"Hw" ∶ (p ---> p and x) --->
       foldr patt_and p (rev l) --->
       foldr patt_and (p and x) (rev l),
"Hx" ∶ x,
"Hf" ∶ foldr patt_and p (rev l),
--------------------------------------
foldr patt_and (p and x) (rev l)
using BasicReasoning

      mlAssert ("Hw'": (foldr patt_and p (rev l) ---> foldr patt_and (p and x) (rev l))).
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x, p: Pattern
l: list Pattern
r: ImpReshapeS g' (x :: rev l ++ [p])
wf2: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wf1: well_formed (foldr patt_and x (rev l ++ [p]))
H: Γ
⊢i foldr patt_imp (x and foldr patt_and p (rev l))
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂))
using i
well_formed
  (foldr patt_and p (rev l) --->
   foldr patt_and (p and x) (rev l))
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x, p: Pattern
l: list Pattern
r: ImpReshapeS g' (x :: rev l ++ [p])
wf2: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wf1: well_formed (foldr patt_and x (rev l ++ [p]))
H: Γ
⊢i foldr patt_imp (x and foldr patt_and p (rev l))
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂))
using i
Hwf: well_formed
  (foldr patt_and p (rev l) --->
   foldr patt_and (p and x) (rev l))
Γ Ⱶ
"Hw" ∶ (p ---> p and x) --->
       foldr patt_and p (rev l) --->
       foldr patt_and (p and x) (rev l),
"Hx" ∶ x,
"Hf" ∶ foldr patt_and p (rev l),
--------------------------------------
foldr patt_and p (rev l) --->
foldr patt_and (p and x) (rev l)
using BasicReasoning
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x, p: Pattern
l: list Pattern
r: ImpReshapeS g' (x :: rev l ++ [p])
wf2: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wf1: well_formed (foldr patt_and x (rev l ++ [p]))
H: Γ
⊢i foldr patt_imp (x and foldr patt_and p (rev l))
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂))
using i
Hwf: well_formed
  (foldr patt_and p (rev l) --->
   foldr patt_and (p and x) (rev l))
Γ Ⱶ
"Hw" ∶ (p ---> p and x) --->
       foldr patt_and p (rev l) --->
       foldr patt_and (p and x) (rev l),
"Hx" ∶ x,
"Hf" ∶ foldr patt_and p (rev l),
"Hw'" ∶ foldr patt_and p (rev l) --->
        foldr patt_and (p and x) (rev l),
--------------------------------------
foldr patt_and (p and x) (rev l)
using BasicReasoning

      {
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x, p: Pattern
l: list Pattern
r: ImpReshapeS g' (x :: rev l ++ [p])
wf2: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wf1: well_formed (foldr patt_and x (rev l ++ [p]))
H: Γ
⊢i foldr patt_imp (x and foldr patt_and p (rev l))
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂))
using i
well_formed
  (foldr patt_and p (rev l) --->
   foldr patt_and (p and x) (rev l)) wf_auto2. }
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x, p: Pattern
l: list Pattern
r: ImpReshapeS g' (x :: rev l ++ [p])
wf2: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wf1: well_formed (foldr patt_and x (rev l ++ [p]))
H: Γ
⊢i foldr patt_imp (x and foldr patt_and p (rev l))
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂))
using i
Hwf: well_formed
  (foldr patt_and p (rev l) --->
   foldr patt_and (p and x) (rev l))
Γ Ⱶ
"Hw" ∶ (p ---> p and x) --->
       foldr patt_and p (rev l) --->
       foldr patt_and (p and x) (rev l),
"Hx" ∶ x,
"Hf" ∶ foldr patt_and p (rev l),
--------------------------------------
foldr patt_and p (rev l) --->
foldr patt_and (p and x) (rev l)
using BasicReasoning
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x, p: Pattern
l: list Pattern
r: ImpReshapeS g' (x :: rev l ++ [p])
wf2: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wf1: well_formed (foldr patt_and x (rev l ++ [p]))
H: Γ
⊢i foldr patt_imp (x and foldr patt_and p (rev l))
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂))
using i
Hwf: well_formed
  (foldr patt_and p (rev l) --->
   foldr patt_and (p and x) (rev l))
Γ Ⱶ
"Hw" ∶ (p ---> p and x) --->
       foldr patt_and p (rev l) --->
       foldr patt_and (p and x) (rev l),
"Hx" ∶ x,
"Hf" ∶ foldr patt_and p (rev l),
"Hw'" ∶ foldr patt_and p (rev l) --->
        foldr patt_and (p and x) (rev l),
--------------------------------------
foldr patt_and (p and x) (rev l)
using BasicReasoning

      {
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x, p: Pattern
l: list Pattern
r: ImpReshapeS g' (x :: rev l ++ [p])
wf2: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wf1: well_formed (foldr patt_and x (rev l ++ [p]))
H: Γ
⊢i foldr patt_imp (x and foldr patt_and p (rev l))
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂))
using i
Hwf: well_formed
  (foldr patt_and p (rev l) --->
   foldr patt_and (p and x) (rev l))
Γ Ⱶ
"Hw" ∶ (p ---> p and x) --->
       foldr patt_and p (rev l) --->
       foldr patt_and (p and x) (rev l),
"Hx" ∶ x,
"Hf" ∶ foldr patt_and p (rev l),
--------------------------------------
foldr patt_and p (rev l) --->
foldr patt_and (p and x) (rev l)
using BasicReasoning

        mlApply "Hw".
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x, p: Pattern
l: list Pattern
r: ImpReshapeS g' (x :: rev l ++ [p])
wf2: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wf1: well_formed (foldr patt_and x (rev l ++ [p]))
H: Γ
⊢i foldr patt_imp (x and foldr patt_and p (rev l))
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂))
using i
Hwf: well_formed
  (foldr patt_and p (rev l) --->
   foldr patt_and (p and x) (rev l))
Γ Ⱶ
"Hw" ∶ (p ---> p and x) --->
       foldr patt_and p (rev l) --->
       foldr patt_and (p and x) (rev l),
"Hx" ∶ x,
"Hf" ∶ foldr patt_and p (rev l),
--------------------------------------
p ---> p and x
using BasicReasoning

        mlIntro "Hp".
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x, p: Pattern
l: list Pattern
r: ImpReshapeS g' (x :: rev l ++ [p])
wf2: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wf1: well_formed (foldr patt_and x (rev l ++ [p]))
H: Γ
⊢i foldr patt_imp (x and foldr patt_and p (rev l))
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂))
using i
Hwf: well_formed
  (foldr patt_and p (rev l) --->
   foldr patt_and (p and x) (rev l))
Γ Ⱶ
"Hw" ∶ (p ---> p and x) --->
       foldr patt_and p (rev l) --->
       foldr patt_and (p and x) (rev l),
"Hx" ∶ x,
"Hf" ∶ foldr patt_and p (rev l),
"Hp" ∶ p,
--------------------------------------
p and x
using BasicReasoning

        mlSplitAnd;[mlExact "Hp" | mlExact "Hx"].
      }
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x, p: Pattern
l: list Pattern
r: ImpReshapeS g' (x :: rev l ++ [p])
wf2: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wf1: well_formed (foldr patt_and x (rev l ++ [p]))
H: Γ
⊢i foldr patt_imp (x and foldr patt_and p (rev l))
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂))
using i
Hwf: well_formed
  (foldr patt_and p (rev l) --->
   foldr patt_and (p and x) (rev l))
Γ Ⱶ
"Hw" ∶ (p ---> p and x) --->
       foldr patt_and p (rev l) --->
       foldr patt_and (p and x) (rev l),
"Hx" ∶ x,
"Hf" ∶ foldr patt_and p (rev l),
"Hw'" ∶ foldr patt_and p (rev l) --->
        foldr patt_and (p and x) (rev l),
--------------------------------------
foldr patt_and (p and x) (rev l)
using BasicReasoning

      mlClear "Hw".
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x, p: Pattern
l: list Pattern
r: ImpReshapeS g' (x :: rev l ++ [p])
wf2: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wf1: well_formed (foldr patt_and x (rev l ++ [p]))
H: Γ
⊢i foldr patt_imp (x and foldr patt_and p (rev l))
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂))
using i
Hwf: well_formed
  (foldr patt_and p (rev l) --->
   foldr patt_and (p and x) (rev l))
Γ Ⱶ
"Hx" ∶ x,
"Hf" ∶ foldr patt_and p (rev l),
"Hw'" ∶ foldr patt_and p (rev l) --->
        foldr patt_and (p and x) (rev l),
--------------------------------------
foldr patt_and (p and x) (rev l)
using BasicReasoning

      mlApply "Hw'".
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x, p: Pattern
l: list Pattern
r: ImpReshapeS g' (x :: rev l ++ [p])
wf2: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wf1: well_formed (foldr patt_and x (rev l ++ [p]))
H: Γ
⊢i foldr patt_imp (x and foldr patt_and p (rev l))
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂))
using i
Hwf: well_formed
  (foldr patt_and p (rev l) --->
   foldr patt_and (p and x) (rev l))
Γ Ⱶ
"Hx" ∶ x,
"Hf" ∶ foldr patt_and p (rev l),
"Hw'" ∶ foldr patt_and p (rev l) --->
        foldr patt_and (p and x) (rev l),
--------------------------------------
foldr patt_and p (rev l)
using BasicReasoning

      mlExact "Hf".
    }
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x, p: Pattern
l: list Pattern
r: ImpReshapeS g' (x :: rev l ++ [p])
wf2: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wf1: well_formed (foldr patt_and x (rev l ++ [p]))
H: Γ
⊢i foldr patt_imp (x and foldr patt_and p (rev l))
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂))
using i
wf (map nh_patt (l₁ ++ (name ∶ r) :: l₂))
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x, p: Pattern
l: list Pattern
r: ImpReshapeS g' (x :: rev l ++ [p])
wf2: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wf1: well_formed (foldr patt_and x (rev l ++ [p]))
H: Γ
⊢i foldr patt_imp (x and foldr patt_and p (rev l))
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂))
using i
well_formed (x and foldr patt_and p (rev l))
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x, p: Pattern
l: list Pattern
r: ImpReshapeS g' (x :: rev l ++ [p])
wf2: foldr andb true
  (map well_formed
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wf1: well_formed (foldr patt_and x (rev l ++ [p]))
H: Γ
⊢i foldr patt_imp (x and foldr patt_and p (rev l))
     (map nh_patt (l₁ ++ (name ∶ r) :: l₂))
using i
well_formed (foldr patt_and x (rev l ++ [p]))
    1,2,3: wf_auto2.
  }
Defined.

Tactic Notation "_mlApplyBasic" constr(name') :=
  _ensureProofMode;
  _mlReshapeHypsByName name';
  apply MLGoal_weakenConclusion;
  _mlReshapeHypsBack;
  cbn.


Tactic Notation "_mlApplyGen" constr(name') :=
  _ensureProofMode;
  _mlReshapeHypsByName name';
  apply MLGoal_weakenConclusionGen;
  _mlReshapeHypsBack;
  cbn.

#[local]
Example ex_mlApplyGeneralized  {Σ : Signature} Γ a b c d e f g:
  well_formed a ->
  well_formed b ->
  well_formed c ->
  well_formed d ->
  well_formed e ->
  well_formed f ->
  well_formed g ->
  Γ ⊢ ((a and (b and (c and (d and e)))) --->
       (a ---> b ---> c ---> d ---> e ---> f) --->
       (f ---> g) --->
       g).
Σ: Signature
Γ: Theory
a, b, c, d, e, f, g: Pattern
well_formed a
→ well_formed b
  → well_formed c
    → well_formed d
      → well_formed e
        → well_formed f
          → well_formed g
            → Γ
              ⊢ a and (b and (c and (d and e))) --->
                (a ---> b ---> c ---> d ---> e ---> f) --->
                (f ---> g) ---> g
Proof.
Σ: Signature
Γ: Theory
a, b, c, d, e, f, g: Pattern
well_formed a
→ well_formed b
  → well_formed c
    → well_formed d
      → well_formed e
        → well_formed f
          → well_formed g
            → Γ
              ⊢ a and (b and (c and (d and e))) --->
                (a ---> b ---> c ---> d ---> e ---> f) --->
                (f ---> g) ---> g
  intros wfa wfb wfc wfd wfe wff wfg.
Σ: Signature
Γ: Theory
a, b, c, d, e, f, g: Pattern
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
wfd: well_formed d
wfe: well_formed e
wff: well_formed f
wfg: well_formed g
Γ
⊢ a and (b and (c and (d and e))) --->
  (a ---> b ---> c ---> d ---> e ---> f) --->
  (f ---> g) ---> g
  toMLGoal.
Σ: Signature
Γ: Theory
a, b, c, d, e, f, g: Pattern
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
wfd: well_formed d
wfe: well_formed e
wff: well_formed f
wfg: well_formed g
well_formed
  (a and (b and (c and (d and e))) --->
   (a ---> b ---> c ---> d ---> e ---> f) --->
   (f ---> g) ---> g)
Σ: Signature
Γ: Theory
a, b, c, d, e, f, g: Pattern
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
wfd: well_formed d
wfe: well_formed e
wff: well_formed f
wfg: well_formed g
Γ Ⱶ
 a and (b and (c and (d and e))) --->
 (a ---> b ---> c ---> d ---> e ---> f) --->
 (f ---> g) ---> g

  {
Σ: Signature
Γ: Theory
a, b, c, d, e, f, g: Pattern
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
wfd: well_formed d
wfe: well_formed e
wff: well_formed f
wfg: well_formed g
well_formed
  (a and (b and (c and (d and e))) --->
   (a ---> b ---> c ---> d ---> e ---> f) --->
   (f ---> g) ---> g) wf_auto2. }
Σ: Signature
Γ: Theory
a, b, c, d, e, f, g: Pattern
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
wfd: well_formed d
wfe: well_formed e
wff: well_formed f
wfg: well_formed g
Γ Ⱶ
 a and (b and (c and (d and e))) --->
 (a ---> b ---> c ---> d ---> e ---> f) --->
 (f ---> g) ---> g

  mlIntro "H1".
Σ: Signature
Γ: Theory
a, b, c, d, e, f, g: Pattern
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
wfd: well_formed d
wfe: well_formed e
wff: well_formed f
wfg: well_formed g
Γ Ⱶ
"H1" ∶ a and (b and (c and (d and e))),
--------------------------------------
(a ---> b ---> c ---> d ---> e ---> f) --->
(f ---> g) ---> g

  mlIntro "H2".
Σ: Signature
Γ: Theory
a, b, c, d, e, f, g: Pattern
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
wfd: well_formed d
wfe: well_formed e
wff: well_formed f
wfg: well_formed g
Γ Ⱶ
"H1" ∶ a and (b and (c and (d and e))),
"H2" ∶ a ---> b ---> c ---> d ---> e ---> f,
--------------------------------------
(f ---> g) ---> g

  mlIntro "H3".
Σ: Signature
Γ: Theory
a, b, c, d, e, f, g: Pattern
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
wfd: well_formed d
wfe: well_formed e
wff: well_formed f
wfg: well_formed g
Γ Ⱶ
"H1" ∶ a and (b and (c and (d and e))),
"H2" ∶ a ---> b ---> c ---> d ---> e ---> f,
"H3" ∶ f ---> g,
--------------------------------------
g


  _mlApplyGen "H3".
Σ: Signature
Γ: Theory
a, b, c, d, e, f, g: Pattern
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
wfd: well_formed d
wfe: well_formed e
wff: well_formed f
wfg: well_formed g
Γ Ⱶ
"H1" ∶ a and (b and (c and (d and e))),
"H2" ∶ a ---> b ---> c ---> d ---> e ---> f,
"H3" ∶ f ---> g,
--------------------------------------
f

  _mlApplyGen "H2".
Σ: Signature
Γ: Theory
a, b, c, d, e, f, g: Pattern
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
wfd: well_formed d
wfe: well_formed e
wff: well_formed f
wfg: well_formed g
Γ Ⱶ
"H1" ∶ a and (b and (c and (d and e))),
"H2" ∶ a ---> b ---> c ---> d ---> e ---> f,
"H3" ∶ f ---> g,
--------------------------------------
a and (b and (c and (d and e)))

  mlExact "H1".
Defined.

Tactic Notation "mlApply" constr(name') :=
  (_mlApplyBasic name') || (_mlApplyGen name')
.

Section FOL_helpers.

  Context {Σ : Signature}.

  Lemma Framing_left (Γ : Theory) (ϕ₁ ϕ₂ ψ : Pattern) (i : ProofInfo)
    (wfψ : well_formed ψ)
    {pile : ProofInfoLe ((ExGen := ∅, SVSubst := ∅, KT := false)) i}
    :
    Γ ⊢i ϕ₁ ---> ϕ₂ using i ->
    Γ ⊢i ϕ₁ $ ψ ---> ϕ₂ $ ψ using i.
Σ: Signature
Γ: Theory
ϕ₁, ϕ₂, ψ: Pattern
i: ProofInfo
wfψ: well_formed ψ
pile: ProofInfoLe
  (ExGen := ∅, SVSubst := ∅, KT := false) i
Γ ⊢i ϕ₁ ---> ϕ₂ using i
→ Γ ⊢i ϕ₁ $ ψ ---> ϕ₂ $ ψ using i
  Proof.
Σ: Signature
Γ: Theory
ϕ₁, ϕ₂, ψ: Pattern
i: ProofInfo
wfψ: well_formed ψ
pile: ProofInfoLe
  (ExGen := ∅, SVSubst := ∅, KT := false) i
Γ ⊢i ϕ₁ ---> ϕ₂ using i
→ Γ ⊢i ϕ₁ $ ψ ---> ϕ₂ $ ψ using i
    intros [pf Hpf].
Σ: Signature
Γ: Theory
ϕ₁, ϕ₂, ψ: Pattern
i: ProofInfo
wfψ: well_formed ψ
pile: ProofInfoLe
  (ExGen := ∅, SVSubst := ∅, KT := false) i
pf: ML_proof_system Γ (ϕ₁ ---> ϕ₂)
Hpf: ProofInfoMeaning Γ (ϕ₁ ---> ϕ₂) pf i
Γ ⊢i ϕ₁ $ ψ ---> ϕ₂ $ ψ using i
    unshelve (eexists).
Σ: Signature
Γ: Theory
ϕ₁, ϕ₂, ψ: Pattern
i: ProofInfo
wfψ: well_formed ψ
pile: ProofInfoLe
  (ExGen := ∅, SVSubst := ∅, KT := false) i
pf: ML_proof_system Γ (ϕ₁ ---> ϕ₂)
Hpf: ProofInfoMeaning Γ (ϕ₁ ---> ϕ₂) pf i
ML_proof_system Γ (ϕ₁ $ ψ ---> ϕ₂ $ ψ)
Σ: Signature
Γ: Theory
ϕ₁, ϕ₂, ψ: Pattern
i: ProofInfo
wfψ: well_formed ψ
pile: ProofInfoLe
  (ExGen := ∅, SVSubst := ∅, KT := false) i
pf: ML_proof_system Γ (ϕ₁ ---> ϕ₂)
Hpf: ProofInfoMeaning Γ (ϕ₁ ---> ϕ₂) pf i
ProofInfoMeaning Γ (ϕ₁ $ ψ ---> ϕ₂ $ ψ) ?pf i
    {
Σ: Signature
Γ: Theory
ϕ₁, ϕ₂, ψ: Pattern
i: ProofInfo
wfψ: well_formed ψ
pile: ProofInfoLe
  (ExGen := ∅, SVSubst := ∅, KT := false) i
pf: ML_proof_system Γ (ϕ₁ ---> ϕ₂)
Hpf: ProofInfoMeaning Γ (ϕ₁ ---> ϕ₂) pf i
ML_proof_system Γ (ϕ₁ $ ψ ---> ϕ₂ $ ψ)
      apply ProofSystem.Framing_left.
Σ: Signature
Γ: Theory
ϕ₁, ϕ₂, ψ: Pattern
i: ProofInfo
wfψ: well_formed ψ
pile: ProofInfoLe
  (ExGen := ∅, SVSubst := ∅, KT := false) i
pf: ML_proof_system Γ (ϕ₁ ---> ϕ₂)
Hpf: ProofInfoMeaning Γ (ϕ₁ ---> ϕ₂) pf i
well_formed ψ
Σ: Signature
Γ: Theory
ϕ₁, ϕ₂, ψ: Pattern
i: ProofInfo
wfψ: well_formed ψ
pile: ProofInfoLe
  (ExGen := ∅, SVSubst := ∅, KT := false) i
pf: ML_proof_system Γ (ϕ₁ ---> ϕ₂)
Hpf: ProofInfoMeaning Γ (ϕ₁ ---> ϕ₂) pf i
ML_proof_system Γ (ϕ₁ ---> ϕ₂)
      {
Σ: Signature
Γ: Theory
ϕ₁, ϕ₂, ψ: Pattern
i: ProofInfo
wfψ: well_formed ψ
pile: ProofInfoLe
  (ExGen := ∅, SVSubst := ∅, KT := false) i
pf: ML_proof_system Γ (ϕ₁ ---> ϕ₂)
Hpf: ProofInfoMeaning Γ (ϕ₁ ---> ϕ₂) pf i
well_formed ψ exact wfψ. }
Σ: Signature
Γ: Theory
ϕ₁, ϕ₂, ψ: Pattern
i: ProofInfo
wfψ: well_formed ψ
pile: ProofInfoLe
  (ExGen := ∅, SVSubst := ∅, KT := false) i
pf: ML_proof_system Γ (ϕ₁ ---> ϕ₂)
Hpf: ProofInfoMeaning Γ (ϕ₁ ---> ϕ₂) pf i
ML_proof_system Γ (ϕ₁ ---> ϕ₂)
      exact pf.
    }
Σ: Signature
Γ: Theory
ϕ₁, ϕ₂, ψ: Pattern
i: ProofInfo
wfψ: well_formed ψ
pile: ProofInfoLe
  (ExGen := ∅, SVSubst := ∅, KT := false) i
pf: ML_proof_system Γ (ϕ₁ ---> ϕ₂)
Hpf: ProofInfoMeaning Γ (ϕ₁ ---> ϕ₂) pf i
ProofInfoMeaning Γ (ϕ₁ $ ψ ---> ϕ₂ $ ψ)
  (Framing_left Γ ϕ₁ ϕ₂ ψ wfψ pf) i
    {
Σ: Signature
Γ: Theory
ϕ₁, ϕ₂, ψ: Pattern
i: ProofInfo
wfψ: well_formed ψ
pile: ProofInfoLe
  (ExGen := ∅, SVSubst := ∅, KT := false) i
pf: ML_proof_system Γ (ϕ₁ ---> ϕ₂)
Hpf: ProofInfoMeaning Γ (ϕ₁ ---> ϕ₂) pf i
ProofInfoMeaning Γ (ϕ₁ $ ψ ---> ϕ₂ $ ψ)
  (Framing_left Γ ϕ₁ ϕ₂ ψ wfψ pf) i
      destruct Hpf as [Hpf1 Hpf2 Hpf3].
Σ: Signature
Γ: Theory
ϕ₁, ϕ₂, ψ: Pattern
i: ProofInfo
wfψ: well_formed ψ
pile: ProofInfoLe
  (ExGen := ∅, SVSubst := ∅, KT := false) i
pf: ML_proof_system Γ (ϕ₁ ---> ϕ₂)
Hpf1: gset_to_coGset
  (uses_of_ex_gen Γ (ϕ₁ ---> ϕ₂) pf)
⊆ pi_generalized_evars i
Hpf2: gset_to_coGset
  (uses_of_svar_subst Γ (ϕ₁ ---> ϕ₂) pf)
⊆ pi_substituted_svars i
Hpf3: uses_kt pf ==> pi_uses_kt i
ProofInfoMeaning Γ (ϕ₁ $ ψ ---> ϕ₂ $ ψ)
  (Framing_left Γ ϕ₁ ϕ₂ ψ wfψ pf) i
      constructor; simpl.
Σ: Signature
Γ: Theory
ϕ₁, ϕ₂, ψ: Pattern
i: ProofInfo
wfψ: well_formed ψ
pile: ProofInfoLe
  (ExGen := ∅, SVSubst := ∅, KT := false) i
pf: ML_proof_system Γ (ϕ₁ ---> ϕ₂)
Hpf1: gset_to_coGset
  (uses_of_ex_gen Γ (ϕ₁ ---> ϕ₂) pf)
⊆ pi_generalized_evars i
Hpf2: gset_to_coGset
  (uses_of_svar_subst Γ (ϕ₁ ---> ϕ₂) pf)
⊆ pi_substituted_svars i
Hpf3: uses_kt pf ==> pi_uses_kt i
gset_to_coGset (uses_of_ex_gen Γ (ϕ₁ ---> ϕ₂) pf)
⊆ pi_generalized_evars i
Σ: Signature
Γ: Theory
ϕ₁, ϕ₂, ψ: Pattern
i: ProofInfo
wfψ: well_formed ψ
pile: ProofInfoLe
  (ExGen := ∅, SVSubst := ∅, KT := false) i
pf: ML_proof_system Γ (ϕ₁ ---> ϕ₂)
Hpf1: gset_to_coGset
  (uses_of_ex_gen Γ (ϕ₁ ---> ϕ₂) pf)
⊆ pi_generalized_evars i
Hpf2: gset_to_coGset
  (uses_of_svar_subst Γ (ϕ₁ ---> ϕ₂) pf)
⊆ pi_substituted_svars i
Hpf3: uses_kt pf ==> pi_uses_kt i
gset_to_coGset (uses_of_svar_subst Γ (ϕ₁ ---> ϕ₂) pf)
⊆ pi_substituted_svars i
Σ: Signature
Γ: Theory
ϕ₁, ϕ₂, ψ: Pattern
i: ProofInfo
wfψ: well_formed ψ
pile: ProofInfoLe
  (ExGen := ∅, SVSubst := ∅, KT := false) i
pf: ML_proof_system Γ (ϕ₁ ---> ϕ₂)
Hpf1: gset_to_coGset
  (uses_of_ex_gen Γ (ϕ₁ ---> ϕ₂) pf)
⊆ pi_generalized_evars i
Hpf2: gset_to_coGset
  (uses_of_svar_subst Γ (ϕ₁ ---> ϕ₂) pf)
⊆ pi_substituted_svars i
Hpf3: uses_kt pf ==> pi_uses_kt i
uses_kt pf ==> pi_uses_kt i
      {
Σ: Signature
Γ: Theory
ϕ₁, ϕ₂, ψ: Pattern
i: ProofInfo
wfψ: well_formed ψ
pile: ProofInfoLe
  (ExGen := ∅, SVSubst := ∅, KT := false) i
pf: ML_proof_system Γ (ϕ₁ ---> ϕ₂)
Hpf1: gset_to_coGset
  (uses_of_ex_gen Γ (ϕ₁ ---> ϕ₂) pf)
⊆ pi_generalized_evars i
Hpf2: gset_to_coGset
  (uses_of_svar_subst Γ (ϕ₁ ---> ϕ₂) pf)
⊆ pi_substituted_svars i
Hpf3: uses_kt pf ==> pi_uses_kt i
gset_to_coGset (uses_of_ex_gen Γ (ϕ₁ ---> ϕ₂) pf)
⊆ pi_generalized_evars i
        assumption.
      }
Σ: Signature
Γ: Theory
ϕ₁, ϕ₂, ψ: Pattern
i: ProofInfo
wfψ: well_formed ψ
pile: ProofInfoLe
  (ExGen := ∅, SVSubst := ∅, KT := false) i
pf: ML_proof_system Γ (ϕ₁ ---> ϕ₂)
Hpf1: gset_to_coGset
  (uses_of_ex_gen Γ (ϕ₁ ---> ϕ₂) pf)
⊆ pi_generalized_evars i
Hpf2: gset_to_coGset
  (uses_of_svar_subst Γ (ϕ₁ ---> ϕ₂) pf)
⊆ pi_substituted_svars i
Hpf3: uses_kt pf ==> pi_uses_kt i
gset_to_coGset (uses_of_svar_subst Γ (ϕ₁ ---> ϕ₂) pf)
⊆ pi_substituted_svars i
Σ: Signature
Γ: Theory
ϕ₁, ϕ₂, ψ: Pattern
i: ProofInfo
wfψ: well_formed ψ
pile: ProofInfoLe
  (ExGen := ∅, SVSubst := ∅, KT := false) i
pf: ML_proof_system Γ (ϕ₁ ---> ϕ₂)
Hpf1: gset_to_coGset
  (uses_of_ex_gen Γ (ϕ₁ ---> ϕ₂) pf)
⊆ pi_generalized_evars i
Hpf2: gset_to_coGset
  (uses_of_svar_subst Γ (ϕ₁ ---> ϕ₂) pf)
⊆ pi_substituted_svars i
Hpf3: uses_kt pf ==> pi_uses_kt i
uses_kt pf ==> pi_uses_kt i
      {
Σ: Signature
Γ: Theory
ϕ₁, ϕ₂, ψ: Pattern
i: ProofInfo
wfψ: well_formed ψ
pile: ProofInfoLe
  (ExGen := ∅, SVSubst := ∅, KT := false) i
pf: ML_proof_system Γ (ϕ₁ ---> ϕ₂)
Hpf1: gset_to_coGset
  (uses_of_ex_gen Γ (ϕ₁ ---> ϕ₂) pf)
⊆ pi_generalized_evars i
Hpf2: gset_to_coGset
  (uses_of_svar_subst Γ (ϕ₁ ---> ϕ₂) pf)
⊆ pi_substituted_svars i
Hpf3: uses_kt pf ==> pi_uses_kt i
gset_to_coGset (uses_of_svar_subst Γ (ϕ₁ ---> ϕ₂) pf)
⊆ pi_substituted_svars i
        assumption.
      }
Σ: Signature
Γ: Theory
ϕ₁, ϕ₂, ψ: Pattern
i: ProofInfo
wfψ: well_formed ψ
pile: ProofInfoLe
  (ExGen := ∅, SVSubst := ∅, KT := false) i
pf: ML_proof_system Γ (ϕ₁ ---> ϕ₂)
Hpf1: gset_to_coGset
  (uses_of_ex_gen Γ (ϕ₁ ---> ϕ₂) pf)
⊆ pi_generalized_evars i
Hpf2: gset_to_coGset
  (uses_of_svar_subst Γ (ϕ₁ ---> ϕ₂) pf)
⊆ pi_substituted_svars i
Hpf3: uses_kt pf ==> pi_uses_kt i
uses_kt pf ==> pi_uses_kt i
      {
Σ: Signature
Γ: Theory
ϕ₁, ϕ₂, ψ: Pattern
i: ProofInfo
wfψ: well_formed ψ
pile: ProofInfoLe
  (ExGen := ∅, SVSubst := ∅, KT := false) i
pf: ML_proof_system Γ (ϕ₁ ---> ϕ₂)
Hpf1: gset_to_coGset
  (uses_of_ex_gen Γ (ϕ₁ ---> ϕ₂) pf)
⊆ pi_generalized_evars i
Hpf2: gset_to_coGset
  (uses_of_svar_subst Γ (ϕ₁ ---> ϕ₂) pf)
⊆ pi_substituted_svars i
Hpf3: uses_kt pf ==> pi_uses_kt i
uses_kt pf ==> pi_uses_kt i
        assumption.
      }
    }
  Defined.

  Lemma Framing_right (Γ : Theory) (ϕ₁ ϕ₂ ψ : Pattern) (i : ProofInfo)
    (wfψ : well_formed ψ)
    {pile : ProofInfoLe ((ExGen := ∅, SVSubst := ∅, KT := false)) i}
    :
    Γ ⊢i ϕ₁ ---> ϕ₂ using i ->
    Γ ⊢i ψ $ ϕ₁ ---> ψ $ ϕ₂ using i.
Σ: Signature
Γ: Theory
ϕ₁, ϕ₂, ψ: Pattern
i: ProofInfo
wfψ: well_formed ψ
pile: ProofInfoLe
  (ExGen := ∅, SVSubst := ∅, KT := false) i
Γ ⊢i ϕ₁ ---> ϕ₂ using i
→ Γ ⊢i ψ $ ϕ₁ ---> ψ $ ϕ₂ using i
  Proof.
Σ: Signature
Γ: Theory
ϕ₁, ϕ₂, ψ: Pattern
i: ProofInfo
wfψ: well_formed ψ
pile: ProofInfoLe
  (ExGen := ∅, SVSubst := ∅, KT := false) i
Γ ⊢i ϕ₁ ---> ϕ₂ using i
→ Γ ⊢i ψ $ ϕ₁ ---> ψ $ ϕ₂ using i
    intros [pf Hpf].
Σ: Signature
Γ: Theory
ϕ₁, ϕ₂, ψ: Pattern
i: ProofInfo
wfψ: well_formed ψ
pile: ProofInfoLe
  (ExGen := ∅, SVSubst := ∅, KT := false) i
pf: ML_proof_system Γ (ϕ₁ ---> ϕ₂)
Hpf: ProofInfoMeaning Γ (ϕ₁ ---> ϕ₂) pf i
Γ ⊢i ψ $ ϕ₁ ---> ψ $ ϕ₂ using i
    unshelve (eexists).
Σ: Signature
Γ: Theory
ϕ₁, ϕ₂, ψ: Pattern
i: ProofInfo
wfψ: well_formed ψ
pile: ProofInfoLe
  (ExGen := ∅, SVSubst := ∅, KT := false) i
pf: ML_proof_system Γ (ϕ₁ ---> ϕ₂)
Hpf: ProofInfoMeaning Γ (ϕ₁ ---> ϕ₂) pf i
ML_proof_system Γ (ψ $ ϕ₁ ---> ψ $ ϕ₂)
Σ: Signature
Γ: Theory
ϕ₁, ϕ₂, ψ: Pattern
i: ProofInfo
wfψ: well_formed ψ
pile: ProofInfoLe
  (ExGen := ∅, SVSubst := ∅, KT := false) i
pf: ML_proof_system Γ (ϕ₁ ---> ϕ₂)
Hpf: ProofInfoMeaning Γ (ϕ₁ ---> ϕ₂) pf i
ProofInfoMeaning Γ (ψ $ ϕ₁ ---> ψ $ ϕ₂) ?pf i
    {
Σ: Signature
Γ: Theory
ϕ₁, ϕ₂, ψ: Pattern
i: ProofInfo
wfψ: well_formed ψ
pile: ProofInfoLe
  (ExGen := ∅, SVSubst := ∅, KT := false) i
pf: ML_proof_system Γ (ϕ₁ ---> ϕ₂)
Hpf: ProofInfoMeaning Γ (ϕ₁ ---> ϕ₂) pf i
ML_proof_system Γ (ψ $ ϕ₁ ---> ψ $ ϕ₂)
      apply ProofSystem.Framing_right.
Σ: Signature
Γ: Theory
ϕ₁, ϕ₂, ψ: Pattern
i: ProofInfo
wfψ: well_formed ψ
pile: ProofInfoLe
  (ExGen := ∅, SVSubst := ∅, KT := false) i
pf: ML_proof_system Γ (ϕ₁ ---> ϕ₂)
Hpf: ProofInfoMeaning Γ (ϕ₁ ---> ϕ₂) pf i
well_formed ψ
Σ: Signature
Γ: Theory
ϕ₁, ϕ₂, ψ: Pattern
i: ProofInfo
wfψ: well_formed ψ
pile: ProofInfoLe
  (ExGen := ∅, SVSubst := ∅, KT := false) i
pf: ML_proof_system Γ (ϕ₁ ---> ϕ₂)
Hpf: ProofInfoMeaning Γ (ϕ₁ ---> ϕ₂) pf i
ML_proof_system Γ (ϕ₁ ---> ϕ₂)
      {
Σ: Signature
Γ: Theory
ϕ₁, ϕ₂, ψ: Pattern
i: ProofInfo
wfψ: well_formed ψ
pile: ProofInfoLe
  (ExGen := ∅, SVSubst := ∅, KT := false) i
pf: ML_proof_system Γ (ϕ₁ ---> ϕ₂)
Hpf: ProofInfoMeaning Γ (ϕ₁ ---> ϕ₂) pf i
well_formed ψ exact wfψ. }
Σ: Signature
Γ: Theory
ϕ₁, ϕ₂, ψ: Pattern
i: ProofInfo
wfψ: well_formed ψ
pile: ProofInfoLe
  (ExGen := ∅, SVSubst := ∅, KT := false) i
pf: ML_proof_system Γ (ϕ₁ ---> ϕ₂)
Hpf: ProofInfoMeaning Γ (ϕ₁ ---> ϕ₂) pf i
ML_proof_system Γ (ϕ₁ ---> ϕ₂)
      exact pf.
    }
Σ: Signature
Γ: Theory
ϕ₁, ϕ₂, ψ: Pattern
i: ProofInfo
wfψ: well_formed ψ
pile: ProofInfoLe
  (ExGen := ∅, SVSubst := ∅, KT := false) i
pf: ML_proof_system Γ (ϕ₁ ---> ϕ₂)
Hpf: ProofInfoMeaning Γ (ϕ₁ ---> ϕ₂) pf i
ProofInfoMeaning Γ (ψ $ ϕ₁ ---> ψ $ ϕ₂)
  (Framing_right Γ ϕ₁ ϕ₂ ψ wfψ pf) i
    {
Σ: Signature
Γ: Theory
ϕ₁, ϕ₂, ψ: Pattern
i: ProofInfo
wfψ: well_formed ψ
pile: ProofInfoLe
  (ExGen := ∅, SVSubst := ∅, KT := false) i
pf: ML_proof_system Γ (ϕ₁ ---> ϕ₂)
Hpf: ProofInfoMeaning Γ (ϕ₁ ---> ϕ₂) pf i
ProofInfoMeaning Γ (ψ $ ϕ₁ ---> ψ $ ϕ₂)
  (Framing_right Γ ϕ₁ ϕ₂ ψ wfψ pf) i
      destruct Hpf as [Hpf1 Hpf2 Hpf3].
Σ: Signature
Γ: Theory
ϕ₁, ϕ₂, ψ: Pattern
i: ProofInfo
wfψ: well_formed ψ
pile: ProofInfoLe
  (ExGen := ∅, SVSubst := ∅, KT := false) i
pf: ML_proof_system Γ (ϕ₁ ---> ϕ₂)
Hpf1: gset_to_coGset
  (uses_of_ex_gen Γ (ϕ₁ ---> ϕ₂) pf)
⊆ pi_generalized_evars i
Hpf2: gset_to_coGset
  (uses_of_svar_subst Γ (ϕ₁ ---> ϕ₂) pf)
⊆ pi_substituted_svars i
Hpf3: uses_kt pf ==> pi_uses_kt i
ProofInfoMeaning Γ (ψ $ ϕ₁ ---> ψ $ ϕ₂)
  (Framing_right Γ ϕ₁ ϕ₂ ψ wfψ pf) i
      constructor; simpl.
Σ: Signature
Γ: Theory
ϕ₁, ϕ₂, ψ: Pattern
i: ProofInfo
wfψ: well_formed ψ
pile: ProofInfoLe
  (ExGen := ∅, SVSubst := ∅, KT := false) i
pf: ML_proof_system Γ (ϕ₁ ---> ϕ₂)
Hpf1: gset_to_coGset
  (uses_of_ex_gen Γ (ϕ₁ ---> ϕ₂) pf)
⊆ pi_generalized_evars i
Hpf2: gset_to_coGset
  (uses_of_svar_subst Γ (ϕ₁ ---> ϕ₂) pf)
⊆ pi_substituted_svars i
Hpf3: uses_kt pf ==> pi_uses_kt i
gset_to_coGset (uses_of_ex_gen Γ (ϕ₁ ---> ϕ₂) pf)
⊆ pi_generalized_evars i
Σ: Signature
Γ: Theory
ϕ₁, ϕ₂, ψ: Pattern
i: ProofInfo
wfψ: well_formed ψ
pile: ProofInfoLe
  (ExGen := ∅, SVSubst := ∅, KT := false) i
pf: ML_proof_system Γ (ϕ₁ ---> ϕ₂)
Hpf1: gset_to_coGset
  (uses_of_ex_gen Γ (ϕ₁ ---> ϕ₂) pf)
⊆ pi_generalized_evars i
Hpf2: gset_to_coGset
  (uses_of_svar_subst Γ (ϕ₁ ---> ϕ₂) pf)
⊆ pi_substituted_svars i
Hpf3: uses_kt pf ==> pi_uses_kt i
gset_to_coGset (uses_of_svar_subst Γ (ϕ₁ ---> ϕ₂) pf)
⊆ pi_substituted_svars i
Σ: Signature
Γ: Theory
ϕ₁, ϕ₂, ψ: Pattern
i: ProofInfo
wfψ: well_formed ψ
pile: ProofInfoLe
  (ExGen := ∅, SVSubst := ∅, KT := false) i
pf: ML_proof_system Γ (ϕ₁ ---> ϕ₂)
Hpf1: gset_to_coGset
  (uses_of_ex_gen Γ (ϕ₁ ---> ϕ₂) pf)
⊆ pi_generalized_evars i
Hpf2: gset_to_coGset
  (uses_of_svar_subst Γ (ϕ₁ ---> ϕ₂) pf)
⊆ pi_substituted_svars i
Hpf3: uses_kt pf ==> pi_uses_kt i
uses_kt pf ==> pi_uses_kt i
      {
Σ: Signature
Γ: Theory
ϕ₁, ϕ₂, ψ: Pattern
i: ProofInfo
wfψ: well_formed ψ
pile: ProofInfoLe
  (ExGen := ∅, SVSubst := ∅, KT := false) i
pf: ML_proof_system Γ (ϕ₁ ---> ϕ₂)
Hpf1: gset_to_coGset
  (uses_of_ex_gen Γ (ϕ₁ ---> ϕ₂) pf)
⊆ pi_generalized_evars i
Hpf2: gset_to_coGset
  (uses_of_svar_subst Γ (ϕ₁ ---> ϕ₂) pf)
⊆ pi_substituted_svars i
Hpf3: uses_kt pf ==> pi_uses_kt i
gset_to_coGset (uses_of_ex_gen Γ (ϕ₁ ---> ϕ₂) pf)
⊆ pi_generalized_evars i
        assumption.
      }
Σ: Signature
Γ: Theory
ϕ₁, ϕ₂, ψ: Pattern
i: ProofInfo
wfψ: well_formed ψ
pile: ProofInfoLe
  (ExGen := ∅, SVSubst := ∅, KT := false) i
pf: ML_proof_system Γ (ϕ₁ ---> ϕ₂)
Hpf1: gset_to_coGset
  (uses_of_ex_gen Γ (ϕ₁ ---> ϕ₂) pf)
⊆ pi_generalized_evars i
Hpf2: gset_to_coGset
  (uses_of_svar_subst Γ (ϕ₁ ---> ϕ₂) pf)
⊆ pi_substituted_svars i
Hpf3: uses_kt pf ==> pi_uses_kt i
gset_to_coGset (uses_of_svar_subst Γ (ϕ₁ ---> ϕ₂) pf)
⊆ pi_substituted_svars i
Σ: Signature
Γ: Theory
ϕ₁, ϕ₂, ψ: Pattern
i: ProofInfo
wfψ: well_formed ψ
pile: ProofInfoLe
  (ExGen := ∅, SVSubst := ∅, KT := false) i
pf: ML_proof_system Γ (ϕ₁ ---> ϕ₂)
Hpf1: gset_to_coGset
  (uses_of_ex_gen Γ (ϕ₁ ---> ϕ₂) pf)
⊆ pi_generalized_evars i
Hpf2: gset_to_coGset
  (uses_of_svar_subst Γ (ϕ₁ ---> ϕ₂) pf)
⊆ pi_substituted_svars i
Hpf3: uses_kt pf ==> pi_uses_kt i
uses_kt pf ==> pi_uses_kt i
      {
Σ: Signature
Γ: Theory
ϕ₁, ϕ₂, ψ: Pattern
i: ProofInfo
wfψ: well_formed ψ
pile: ProofInfoLe
  (ExGen := ∅, SVSubst := ∅, KT := false) i
pf: ML_proof_system Γ (ϕ₁ ---> ϕ₂)
Hpf1: gset_to_coGset
  (uses_of_ex_gen Γ (ϕ₁ ---> ϕ₂) pf)
⊆ pi_generalized_evars i
Hpf2: gset_to_coGset
  (uses_of_svar_subst Γ (ϕ₁ ---> ϕ₂) pf)
⊆ pi_substituted_svars i
Hpf3: uses_kt pf ==> pi_uses_kt i
gset_to_coGset (uses_of_svar_subst Γ (ϕ₁ ---> ϕ₂) pf)
⊆ pi_substituted_svars i
        assumption.
      }
Σ: Signature
Γ: Theory
ϕ₁, ϕ₂, ψ: Pattern
i: ProofInfo
wfψ: well_formed ψ
pile: ProofInfoLe
  (ExGen := ∅, SVSubst := ∅, KT := false) i
pf: ML_proof_system Γ (ϕ₁ ---> ϕ₂)
Hpf1: gset_to_coGset
  (uses_of_ex_gen Γ (ϕ₁ ---> ϕ₂) pf)
⊆ pi_generalized_evars i
Hpf2: gset_to_coGset
  (uses_of_svar_subst Γ (ϕ₁ ---> ϕ₂) pf)
⊆ pi_substituted_svars i
Hpf3: uses_kt pf ==> pi_uses_kt i
uses_kt pf ==> pi_uses_kt i
      {
Σ: Signature
Γ: Theory
ϕ₁, ϕ₂, ψ: Pattern
i: ProofInfo
wfψ: well_formed ψ
pile: ProofInfoLe
  (ExGen := ∅, SVSubst := ∅, KT := false) i
pf: ML_proof_system Γ (ϕ₁ ---> ϕ₂)
Hpf1: gset_to_coGset
  (uses_of_ex_gen Γ (ϕ₁ ---> ϕ₂) pf)
⊆ pi_generalized_evars i
Hpf2: gset_to_coGset
  (uses_of_svar_subst Γ (ϕ₁ ---> ϕ₂) pf)
⊆ pi_substituted_svars i
Hpf3: uses_kt pf ==> pi_uses_kt i
uses_kt pf ==> pi_uses_kt i
        assumption.
      }
    }
  Defined.

  Lemma Prop_bott_left (Γ : Theory) (ϕ : Pattern) :
    well_formed ϕ ->
    Γ ⊢i ⊥ $ ϕ ---> ⊥ using BasicReasoning.
Σ: Signature
Γ: Theory
ϕ: Pattern
well_formed ϕ → Γ ⊢i ⊥ $ ϕ ---> ⊥ using BasicReasoning
  Proof.
Σ: Signature
Γ: Theory
ϕ: Pattern
well_formed ϕ → Γ ⊢i ⊥ $ ϕ ---> ⊥ using BasicReasoning
    intros wfϕ.
Σ: Signature
Γ: Theory
ϕ: Pattern
wfϕ: well_formed ϕ
Γ ⊢i ⊥ $ ϕ ---> ⊥ using BasicReasoning
    unshelve (eexists).
Σ: Signature
Γ: Theory
ϕ: Pattern
wfϕ: well_formed ϕ
ML_proof_system Γ (⊥ $ ϕ ---> ⊥)
Σ: Signature
Γ: Theory
ϕ: Pattern
wfϕ: well_formed ϕ
ProofInfoMeaning Γ (⊥ $ ϕ ---> ⊥) ?pf BasicReasoning
    {
Σ: Signature
Γ: Theory
ϕ: Pattern
wfϕ: well_formed ϕ
ML_proof_system Γ (⊥ $ ϕ ---> ⊥)
      apply ProofSystem.Prop_bott_left.
Σ: Signature
Γ: Theory
ϕ: Pattern
wfϕ: well_formed ϕ
well_formed ϕ exact wfϕ.
    }
Σ: Signature
Γ: Theory
ϕ: Pattern
wfϕ: well_formed ϕ
ProofInfoMeaning Γ (⊥ $ ϕ ---> ⊥)
  (Prop_bott_left Γ ϕ wfϕ) BasicReasoning
    {
Σ: Signature
Γ: Theory
ϕ: Pattern
wfϕ: well_formed ϕ
ProofInfoMeaning Γ (⊥ $ ϕ ---> ⊥)
  (Prop_bott_left Γ ϕ wfϕ) BasicReasoning
      abstract(solve_pim_simple).
    }
  Defined.

  Lemma Prop_bott_right (Γ : Theory) (ϕ : Pattern) :
    well_formed ϕ ->
    Γ ⊢i ϕ $ ⊥ ---> ⊥ using BasicReasoning.
Σ: Signature
Γ: Theory
ϕ: Pattern
well_formed ϕ → Γ ⊢i ϕ $ ⊥ ---> ⊥ using BasicReasoning
  Proof.
Σ: Signature
Γ: Theory
ϕ: Pattern
well_formed ϕ → Γ ⊢i ϕ $ ⊥ ---> ⊥ using BasicReasoning
    intros wfϕ.
Σ: Signature
Γ: Theory
ϕ: Pattern
wfϕ: well_formed ϕ
Γ ⊢i ϕ $ ⊥ ---> ⊥ using BasicReasoning
    unshelve (eexists).
Σ: Signature
Γ: Theory
ϕ: Pattern
wfϕ: well_formed ϕ
ML_proof_system Γ (ϕ $ ⊥ ---> ⊥)
Σ: Signature
Γ: Theory
ϕ: Pattern
wfϕ: well_formed ϕ
ProofInfoMeaning Γ (ϕ $ ⊥ ---> ⊥) ?pf BasicReasoning
    {
Σ: Signature
Γ: Theory
ϕ: Pattern
wfϕ: well_formed ϕ
ML_proof_system Γ (ϕ $ ⊥ ---> ⊥)
      apply ProofSystem.Prop_bott_right.
Σ: Signature
Γ: Theory
ϕ: Pattern
wfϕ: well_formed ϕ
well_formed ϕ exact wfϕ.
    }
Σ: Signature
Γ: Theory
ϕ: Pattern
wfϕ: well_formed ϕ
ProofInfoMeaning Γ (ϕ $ ⊥ ---> ⊥)
  (Prop_bott_right Γ ϕ wfϕ) BasicReasoning
    {
Σ: Signature
Γ: Theory
ϕ: Pattern
wfϕ: well_formed ϕ
ProofInfoMeaning Γ (ϕ $ ⊥ ---> ⊥)
  (Prop_bott_right Γ ϕ wfϕ) BasicReasoning
      abstract(solve_pim_simple).
    }
  Defined.

  Arguments Prop_bott_left _ (_%ml) _ : clear implicits.
  Arguments Prop_bott_right _ (_%ml) _ : clear implicits.

  Lemma Prop_bot_ctx (Γ : Theory) (C : Application_context) :
    Γ ⊢i ((subst_ctx C patt_bott) ---> patt_bott)
    using (ExGen := ∅, SVSubst := ∅, KT := false).
Σ: Signature
Γ: Theory
C: Application_context
Γ ⊢i C.[□↦⊥] ---> ⊥
using (ExGen := ∅, SVSubst := ∅, KT := false)
  Proof.
Σ: Signature
Γ: Theory
C: Application_context
Γ ⊢i C.[□↦⊥] ---> ⊥
using (ExGen := ∅, SVSubst := ∅, KT := false)
    induction C; simpl in *.
Σ: Signature
Γ: Theory
Γ ⊢i ⊥ ---> ⊥
using (ExGen := ∅, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
C: Application_context
p: Pattern
Prf: well_formed p
IHC: Γ ⊢i C.[□↦⊥] ---> ⊥ using (ExGen := ∅, SVSubst := ∅, KT := false)
Γ ⊢i C.[□↦⊥] $ p ---> ⊥
using (ExGen := ∅, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
p: Pattern
C: Application_context
Prf: well_formed p
IHC: Γ ⊢i C.[□↦⊥] ---> ⊥ using (ExGen := ∅, SVSubst := ∅, KT := false)
Γ ⊢i p $ C.[□↦⊥] ---> ⊥
using (ExGen := ∅, SVSubst := ∅, KT := false)
    -
Σ: Signature
Γ: Theory
Γ ⊢i ⊥ ---> ⊥
using (ExGen := ∅, SVSubst := ∅, KT := false) apply useBasicReasoning.
Σ: Signature
Γ: Theory
Γ ⊢i ⊥ ---> ⊥ using BasicReasoning
      apply bot_elim.
Σ: Signature
Γ: Theory
well_formed ⊥
      wf_auto2.
    -
Σ: Signature
Γ: Theory
C: Application_context
p: Pattern
Prf: well_formed p
IHC: Γ ⊢i C.[□↦⊥] ---> ⊥ using (ExGen := ∅, SVSubst := ∅, KT := false)
Γ ⊢i C.[□↦⊥] $ p ---> ⊥
using (ExGen := ∅, SVSubst := ∅, KT := false) eapply syllogism_meta.
Σ: Signature
Γ: Theory
C: Application_context
p: Pattern
Prf: well_formed p
IHC: Γ ⊢i C.[□↦⊥] ---> ⊥ using (ExGen := ∅, SVSubst := ∅, KT := false)
well_formed (C.[□↦⊥] $ p)
Σ: Signature
Γ: Theory
C: Application_context
p: Pattern
Prf: well_formed p
IHC: Γ ⊢i C.[□↦⊥] ---> ⊥ using (ExGen := ∅, SVSubst := ∅, KT := false)
well_formed ?B
Σ: Signature
Γ: Theory
C: Application_context
p: Pattern
Prf: well_formed p
IHC: Γ ⊢i C.[□↦⊥] ---> ⊥ using (ExGen := ∅, SVSubst := ∅, KT := false)
well_formed ⊥
Σ: Signature
Γ: Theory
C: Application_context
p: Pattern
Prf: well_formed p
IHC: Γ ⊢i C.[□↦⊥] ---> ⊥ using (ExGen := ∅, SVSubst := ∅, KT := false)
Γ ⊢i C.[□↦⊥] $ p ---> ?B
using (ExGen := ∅, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
C: Application_context
p: Pattern
Prf: well_formed p
IHC: Γ ⊢i C.[□↦⊥] ---> ⊥ using (ExGen := ∅, SVSubst := ∅, KT := false)
Γ ⊢i ?B ---> ⊥
using (ExGen := ∅, SVSubst := ∅, KT := false)
      5: {
Σ: Signature
Γ: Theory
C: Application_context
p: Pattern
Prf: well_formed p
IHC: Γ ⊢i C.[□↦⊥] ---> ⊥ using (ExGen := ∅, SVSubst := ∅, KT := false)
Γ ⊢i ?B ---> ⊥
using (ExGen := ∅, SVSubst := ∅, KT := false) apply useBasicReasoning.
Σ: Signature
Γ: Theory
C: Application_context
p: Pattern
Prf: well_formed p
IHC: Γ ⊢i C.[□↦⊥] ---> ⊥ using (ExGen := ∅, SVSubst := ∅, KT := false)
Γ ⊢i ?B ---> ⊥ using BasicReasoning apply (Prop_bott_left Γ p ltac:(wf_auto2)). }
Σ: Signature
Γ: Theory
C: Application_context
p: Pattern
Prf: well_formed p
IHC: Γ ⊢i C.[□↦⊥] ---> ⊥ using (ExGen := ∅, SVSubst := ∅, KT := false)
well_formed (C.[□↦⊥] $ p)
Σ: Signature
Γ: Theory
C: Application_context
p: Pattern
Prf: well_formed p
IHC: Γ ⊢i C.[□↦⊥] ---> ⊥ using (ExGen := ∅, SVSubst := ∅, KT := false)
well_formed (⊥ $ p)
Σ: Signature
Γ: Theory
C: Application_context
p: Pattern
Prf: well_formed p
IHC: Γ ⊢i C.[□↦⊥] ---> ⊥ using (ExGen := ∅, SVSubst := ∅, KT := false)
well_formed ⊥
Σ: Signature
Γ: Theory
C: Application_context
p: Pattern
Prf: well_formed p
IHC: Γ ⊢i C.[□↦⊥] ---> ⊥ using (ExGen := ∅, SVSubst := ∅, KT := false)
Γ ⊢i C.[□↦⊥] $ p ---> ⊥ $ p
using (ExGen := ∅, SVSubst := ∅, KT := false)
      4: {
Σ: Signature
Γ: Theory
C: Application_context
p: Pattern
Prf: well_formed p
IHC: Γ ⊢i C.[□↦⊥] ---> ⊥ using (ExGen := ∅, SVSubst := ∅, KT := false)
Γ ⊢i C.[□↦⊥] $ p ---> ⊥ $ p
using (ExGen := ∅, SVSubst := ∅, KT := false) simpl.
Σ: Signature
Γ: Theory
C: Application_context
p: Pattern
Prf: well_formed p
IHC: Γ ⊢i C.[□↦⊥] ---> ⊥ using (ExGen := ∅, SVSubst := ∅, KT := false)
Γ ⊢i C.[□↦⊥] $ p ---> ⊥ $ p
using (ExGen := ∅, SVSubst := ∅, KT := false) eapply useGenericReasoning.
Σ: Signature
Γ: Theory
C: Application_context
p: Pattern
Prf: well_formed p
IHC: Γ ⊢i C.[□↦⊥] ---> ⊥ using (ExGen := ∅, SVSubst := ∅, KT := false)
ProofInfoLe ?i'
  (ExGen := ∅, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
C: Application_context
p: Pattern
Prf: well_formed p
IHC: Γ ⊢i C.[□↦⊥] ---> ⊥ using (ExGen := ∅, SVSubst := ∅, KT := false)
Γ ⊢i C.[□↦⊥] $ p ---> ⊥ $ p using ?i'
           2: eapply (Framing_left _ _ _ _ _ Prf).
Σ: Signature
Γ: Theory
C: Application_context
p: Pattern
Prf: well_formed p
IHC: Γ ⊢i C.[□↦⊥] ---> ⊥ using (ExGen := ∅, SVSubst := ∅, KT := false)
ProofInfoLe ?i'
  (ExGen := ∅, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
C: Application_context
p: Pattern
Prf: well_formed p
IHC: Γ ⊢i C.[□↦⊥] ---> ⊥ using (ExGen := ∅, SVSubst := ∅, KT := false)
Γ ⊢i C.[□↦⊥] ---> ⊥ using ?i'
           1: apply pile_refl.
Σ: Signature
Γ: Theory
C: Application_context
p: Pattern
Prf: well_formed p
IHC: Γ ⊢i C.[□↦⊥] ---> ⊥ using (ExGen := ∅, SVSubst := ∅, KT := false)
Γ ⊢i C.[□↦⊥] ---> ⊥
using (ExGen := ∅, SVSubst := ∅, KT := false)
           eapply useGenericReasoning.
Σ: Signature
Γ: Theory
C: Application_context
p: Pattern
Prf: well_formed p
IHC: Γ ⊢i C.[□↦⊥] ---> ⊥ using (ExGen := ∅, SVSubst := ∅, KT := false)
ProofInfoLe ?i'
  (ExGen := ∅, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
C: Application_context
p: Pattern
Prf: well_formed p
IHC: Γ ⊢i C.[□↦⊥] ---> ⊥ using (ExGen := ∅, SVSubst := ∅, KT := false)
Γ ⊢i C.[□↦⊥] ---> ⊥ using ?i'
           2: apply IHC.
Σ: Signature
Γ: Theory
C: Application_context
p: Pattern
Prf: well_formed p
IHC: Γ ⊢i C.[□↦⊥] ---> ⊥ using (ExGen := ∅, SVSubst := ∅, KT := false)
ProofInfoLe (ExGen := ∅, SVSubst := ∅, KT := false)
  (ExGen := ∅, SVSubst := ∅, KT := false) try_solve_pile.
      }
Σ: Signature
Γ: Theory
C: Application_context
p: Pattern
Prf: well_formed p
IHC: Γ ⊢i C.[□↦⊥] ---> ⊥ using (ExGen := ∅, SVSubst := ∅, KT := false)
well_formed (C.[□↦⊥] $ p)
Σ: Signature
Γ: Theory
C: Application_context
p: Pattern
Prf: well_formed p
IHC: Γ ⊢i C.[□↦⊥] ---> ⊥ using (ExGen := ∅, SVSubst := ∅, KT := false)
well_formed (⊥ $ p)
Σ: Signature
Γ: Theory
C: Application_context
p: Pattern
Prf: well_formed p
IHC: Γ ⊢i C.[□↦⊥] ---> ⊥ using (ExGen := ∅, SVSubst := ∅, KT := false)
well_formed ⊥
      all: try solve [wf_auto2].
       -
Σ: Signature
Γ: Theory
p: Pattern
C: Application_context
Prf: well_formed p
IHC: Γ ⊢i C.[□↦⊥] ---> ⊥ using (ExGen := ∅, SVSubst := ∅, KT := false)
Γ ⊢i p $ C.[□↦⊥] ---> ⊥
using (ExGen := ∅, SVSubst := ∅, KT := false) eapply syllogism_meta.
Σ: Signature
Γ: Theory
p: Pattern
C: Application_context
Prf: well_formed p
IHC: Γ ⊢i C.[□↦⊥] ---> ⊥ using (ExGen := ∅, SVSubst := ∅, KT := false)
well_formed (p $ C.[□↦⊥])
Σ: Signature
Γ: Theory
p: Pattern
C: Application_context
Prf: well_formed p
IHC: Γ ⊢i C.[□↦⊥] ---> ⊥ using (ExGen := ∅, SVSubst := ∅, KT := false)
well_formed ?B
Σ: Signature
Γ: Theory
p: Pattern
C: Application_context
Prf: well_formed p
IHC: Γ ⊢i C.[□↦⊥] ---> ⊥ using (ExGen := ∅, SVSubst := ∅, KT := false)
well_formed ⊥
Σ: Signature
Γ: Theory
p: Pattern
C: Application_context
Prf: well_formed p
IHC: Γ ⊢i C.[□↦⊥] ---> ⊥ using (ExGen := ∅, SVSubst := ∅, KT := false)
Γ ⊢i p $ C.[□↦⊥] ---> ?B
using (ExGen := ∅, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
p: Pattern
C: Application_context
Prf: well_formed p
IHC: Γ ⊢i C.[□↦⊥] ---> ⊥ using (ExGen := ∅, SVSubst := ∅, KT := false)
Γ ⊢i ?B ---> ⊥
using (ExGen := ∅, SVSubst := ∅, KT := false)
           5: {
Σ: Signature
Γ: Theory
p: Pattern
C: Application_context
Prf: well_formed p
IHC: Γ ⊢i C.[□↦⊥] ---> ⊥ using (ExGen := ∅, SVSubst := ∅, KT := false)
Γ ⊢i ?B ---> ⊥
using (ExGen := ∅, SVSubst := ∅, KT := false) apply useBasicReasoning.
Σ: Signature
Γ: Theory
p: Pattern
C: Application_context
Prf: well_formed p
IHC: Γ ⊢i C.[□↦⊥] ---> ⊥ using (ExGen := ∅, SVSubst := ∅, KT := false)
Γ ⊢i ?B ---> ⊥ using BasicReasoning apply (Prop_bott_right Γ p ltac:(wf_auto2)). }
Σ: Signature
Γ: Theory
p: Pattern
C: Application_context
Prf: well_formed p
IHC: Γ ⊢i C.[□↦⊥] ---> ⊥ using (ExGen := ∅, SVSubst := ∅, KT := false)
well_formed (p $ C.[□↦⊥])
Σ: Signature
Γ: Theory
p: Pattern
C: Application_context
Prf: well_formed p
IHC: Γ ⊢i C.[□↦⊥] ---> ⊥ using (ExGen := ∅, SVSubst := ∅, KT := false)
well_formed (p $ ⊥)
Σ: Signature
Γ: Theory
p: Pattern
C: Application_context
Prf: well_formed p
IHC: Γ ⊢i C.[□↦⊥] ---> ⊥ using (ExGen := ∅, SVSubst := ∅, KT := false)
well_formed ⊥
Σ: Signature
Γ: Theory
p: Pattern
C: Application_context
Prf: well_formed p
IHC: Γ ⊢i C.[□↦⊥] ---> ⊥ using (ExGen := ∅, SVSubst := ∅, KT := false)
Γ ⊢i p $ C.[□↦⊥] ---> p $ ⊥
using (ExGen := ∅, SVSubst := ∅, KT := false)
           4: {
Σ: Signature
Γ: Theory
p: Pattern
C: Application_context
Prf: well_formed p
IHC: Γ ⊢i C.[□↦⊥] ---> ⊥ using (ExGen := ∅, SVSubst := ∅, KT := false)
Γ ⊢i p $ C.[□↦⊥] ---> p $ ⊥
using (ExGen := ∅, SVSubst := ∅, KT := false) simpl.
Σ: Signature
Γ: Theory
p: Pattern
C: Application_context
Prf: well_formed p
IHC: Γ ⊢i C.[□↦⊥] ---> ⊥ using (ExGen := ∅, SVSubst := ∅, KT := false)
Γ ⊢i p $ C.[□↦⊥] ---> p $ ⊥
using (ExGen := ∅, SVSubst := ∅, KT := false) eapply useGenericReasoning.
Σ: Signature
Γ: Theory
p: Pattern
C: Application_context
Prf: well_formed p
IHC: Γ ⊢i C.[□↦⊥] ---> ⊥ using (ExGen := ∅, SVSubst := ∅, KT := false)
ProofInfoLe ?i'
  (ExGen := ∅, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
p: Pattern
C: Application_context
Prf: well_formed p
IHC: Γ ⊢i C.[□↦⊥] ---> ⊥ using (ExGen := ∅, SVSubst := ∅, KT := false)
Γ ⊢i p $ C.[□↦⊥] ---> p $ ⊥ using ?i'
                2: eapply (Framing_right _ _ _ _ _ Prf).
Σ: Signature
Γ: Theory
p: Pattern
C: Application_context
Prf: well_formed p
IHC: Γ ⊢i C.[□↦⊥] ---> ⊥ using (ExGen := ∅, SVSubst := ∅, KT := false)
ProofInfoLe ?i'
  (ExGen := ∅, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
p: Pattern
C: Application_context
Prf: well_formed p
IHC: Γ ⊢i C.[□↦⊥] ---> ⊥ using (ExGen := ∅, SVSubst := ∅, KT := false)
Γ ⊢i C.[□↦⊥] ---> ⊥ using ?i'
                1: apply pile_refl.
Σ: Signature
Γ: Theory
p: Pattern
C: Application_context
Prf: well_formed p
IHC: Γ ⊢i C.[□↦⊥] ---> ⊥ using (ExGen := ∅, SVSubst := ∅, KT := false)
Γ ⊢i C.[□↦⊥] ---> ⊥
using (ExGen := ∅, SVSubst := ∅, KT := false)
                eapply useGenericReasoning.
Σ: Signature
Γ: Theory
p: Pattern
C: Application_context
Prf: well_formed p
IHC: Γ ⊢i C.[□↦⊥] ---> ⊥ using (ExGen := ∅, SVSubst := ∅, KT := false)
ProofInfoLe ?i'
  (ExGen := ∅, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
p: Pattern
C: Application_context
Prf: well_formed p
IHC: Γ ⊢i C.[□↦⊥] ---> ⊥ using (ExGen := ∅, SVSubst := ∅, KT := false)
Γ ⊢i C.[□↦⊥] ---> ⊥ using ?i'
                2: apply IHC.
Σ: Signature
Γ: Theory
p: Pattern
C: Application_context
Prf: well_formed p
IHC: Γ ⊢i C.[□↦⊥] ---> ⊥ using (ExGen := ∅, SVSubst := ∅, KT := false)
ProofInfoLe (ExGen := ∅, SVSubst := ∅, KT := false)
  (ExGen := ∅, SVSubst := ∅, KT := false)
                try_solve_pile.
           }
Σ: Signature
Γ: Theory
p: Pattern
C: Application_context
Prf: well_formed p
IHC: Γ ⊢i C.[□↦⊥] ---> ⊥ using (ExGen := ∅, SVSubst := ∅, KT := false)
well_formed (p $ C.[□↦⊥])
Σ: Signature
Γ: Theory
p: Pattern
C: Application_context
Prf: well_formed p
IHC: Γ ⊢i C.[□↦⊥] ---> ⊥ using (ExGen := ∅, SVSubst := ∅, KT := false)
well_formed (p $ ⊥)
Σ: Signature
Γ: Theory
p: Pattern
C: Application_context
Prf: well_formed p
IHC: Γ ⊢i C.[□↦⊥] ---> ⊥ using (ExGen := ∅, SVSubst := ∅, KT := false)
well_formed ⊥
  Unshelve.
Σ: Signature
Γ: Theory
p: Pattern
C: Application_context
Prf: well_formed p
IHC: Γ ⊢i C.[□↦⊥] ---> ⊥ using (ExGen := ∅, SVSubst := ∅, KT := false)
well_formed (p $ C.[□↦⊥])
Σ: Signature
Γ: Theory
p: Pattern
C: Application_context
Prf: well_formed p
IHC: Γ ⊢i C.[□↦⊥] ---> ⊥ using (ExGen := ∅, SVSubst := ∅, KT := false)
well_formed (p $ ⊥)
Σ: Signature
Γ: Theory
p: Pattern
C: Application_context
Prf: well_formed p
IHC: Γ ⊢i C.[□↦⊥] ---> ⊥ using (ExGen := ∅, SVSubst := ∅, KT := false)
well_formed ⊥
Σ: Signature
Γ: Theory
C: Application_context
p: Pattern
Prf: well_formed p
IHC: Γ ⊢i C.[□↦⊥] ---> ⊥ using (ExGen := ∅, SVSubst := ∅, KT := false)
ProofInfoLe (ExGen := ∅, SVSubst := ∅, KT := false)
  (ExGen := ∅, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
p: Pattern
C: Application_context
Prf: well_formed p
IHC: Γ ⊢i C.[□↦⊥] ---> ⊥ using (ExGen := ∅, SVSubst := ∅, KT := false)
ProofInfoLe (ExGen := ∅, SVSubst := ∅, KT := false)
  (ExGen := ∅, SVSubst := ∅, KT := false)
    1-3: wf_auto2.
Σ: Signature
Γ: Theory
C: Application_context
p: Pattern
Prf: well_formed p
IHC: Γ ⊢i C.[□↦⊥] ---> ⊥ using (ExGen := ∅, SVSubst := ∅, KT := false)
ProofInfoLe (ExGen := ∅, SVSubst := ∅, KT := false)
  (ExGen := ∅, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
p: Pattern
C: Application_context
Prf: well_formed p
IHC: Γ ⊢i C.[□↦⊥] ---> ⊥ using (ExGen := ∅, SVSubst := ∅, KT := false)
ProofInfoLe (ExGen := ∅, SVSubst := ∅, KT := false)
  (ExGen := ∅, SVSubst := ∅, KT := false)
    1-2: try_solve_pile.
  Defined.

  Lemma Framing (Γ : Theory) (C : Application_context) (A B : Pattern) (i : ProofInfo)
    {pile : ProofInfoLe
     ((ExGen := ∅, SVSubst := ∅, KT := false))
     i
    }
    :
    Γ ⊢i (A ---> B) using i ->
    Γ ⊢i ((subst_ctx C A) ---> (subst_ctx C B)) using i.
Σ: Signature
Γ: Theory
C: Application_context
A, B: Pattern
i: ProofInfo
pile: ProofInfoLe
  (ExGen := ∅, SVSubst := ∅, KT := false) i
Γ ⊢i A ---> B using i
→ Γ ⊢i C.[□↦A] ---> C.[□↦B] using i
  Proof.
Σ: Signature
Γ: Theory
C: Application_context
A, B: Pattern
i: ProofInfo
pile: ProofInfoLe
  (ExGen := ∅, SVSubst := ∅, KT := false) i
Γ ⊢i A ---> B using i
→ Γ ⊢i C.[□↦A] ---> C.[□↦B] using i
    intros H.
Σ: Signature
Γ: Theory
C: Application_context
A, B: Pattern
i: ProofInfo
pile: ProofInfoLe
  (ExGen := ∅, SVSubst := ∅, KT := false) i
H: Γ ⊢i A ---> B using i
Γ ⊢i C.[□↦A] ---> C.[□↦B] using i
    pose proof H as [pf _].
Σ: Signature
Γ: Theory
C: Application_context
A, B: Pattern
i: ProofInfo
pile: ProofInfoLe
  (ExGen := ∅, SVSubst := ∅, KT := false) i
H: Γ ⊢i A ---> B using i
pf: ML_proof_system Γ (A ---> B)
Γ ⊢i C.[□↦A] ---> C.[□↦B] using i
    pose proof (HWF := proved_impl_wf _ _ pf).
Σ: Signature
Γ: Theory
C: Application_context
A, B: Pattern
i: ProofInfo
pile: ProofInfoLe
  (ExGen := ∅, SVSubst := ∅, KT := false) i
H: Γ ⊢i A ---> B using i
pf: ML_proof_system Γ (A ---> B)
HWF: well_formed (A ---> B)
Γ ⊢i C.[□↦A] ---> C.[□↦B] using i
    assert (wfA: well_formed A) by wf_auto2.
Σ: Signature
Γ: Theory
C: Application_context
A, B: Pattern
i: ProofInfo
pile: ProofInfoLe
  (ExGen := ∅, SVSubst := ∅, KT := false) i
H: Γ ⊢i A ---> B using i
pf: ML_proof_system Γ (A ---> B)
HWF: well_formed (A ---> B)
wfA: well_formed A
Γ ⊢i C.[□↦A] ---> C.[□↦B] using i
    assert (wfB: well_formed B) by wf_auto2.
Σ: Signature
Γ: Theory
C: Application_context
A, B: Pattern
i: ProofInfo
pile: ProofInfoLe
  (ExGen := ∅, SVSubst := ∅, KT := false) i
H: Γ ⊢i A ---> B using i
pf: ML_proof_system Γ (A ---> B)
HWF: well_formed (A ---> B)
wfA: well_formed A
wfB: well_formed B
Γ ⊢i C.[□↦A] ---> C.[□↦B] using i
    clear pf HWF.
Σ: Signature
Γ: Theory
C: Application_context
A, B: Pattern
i: ProofInfo
pile: ProofInfoLe
  (ExGen := ∅, SVSubst := ∅, KT := false) i
H: Γ ⊢i A ---> B using i
wfA: well_formed A
wfB: well_formed B
Γ ⊢i C.[□↦A] ---> C.[□↦B] using i

    move: wfA wfB H.
Σ: Signature
Γ: Theory
C: Application_context
A, B: Pattern
i: ProofInfo
pile: ProofInfoLe
  (ExGen := ∅, SVSubst := ∅, KT := false) i
well_formed A
→ well_formed B
  → Γ ⊢i A ---> B using i
    → Γ ⊢i C.[□↦A] ---> C.[□↦B] using i
    induction C; intros WFA WFB H; simpl in *.
Σ: Signature
Γ: Theory
A, B: Pattern
i: ProofInfo
pile: ProofInfoLe
  (ExGen := ∅, SVSubst := ∅, KT := false) i
WFA: well_formed A
WFB: well_formed B
H: Γ ⊢i A ---> B using i
Γ ⊢i A ---> B using i
Σ: Signature
Γ: Theory
C: Application_context
p: Pattern
Prf: well_formed p
A, B: Pattern
i: ProofInfo
pile: ProofInfoLe
  (ExGen := ∅, SVSubst := ∅, KT := false) i
IHC: well_formed A
→ well_formed B
  → Γ ⊢i A ---> B using i
    → Γ ⊢i C.[□↦A] ---> C.[□↦B] using i
WFA: well_formed A
WFB: well_formed B
H: Γ ⊢i A ---> B using i
Γ ⊢i C.[□↦A] $ p ---> C.[□↦B] $ p using i
Σ: Signature
Γ: Theory
p: Pattern
C: Application_context
Prf: well_formed p
A, B: Pattern
i: ProofInfo
pile: ProofInfoLe
  (ExGen := ∅, SVSubst := ∅, KT := false) i
IHC: well_formed A
→ well_formed B
  → Γ ⊢i A ---> B using i
    → Γ ⊢i C.[□↦A] ---> C.[□↦B] using i
WFA: well_formed A
WFB: well_formed B
H: Γ ⊢i A ---> B using i
Γ ⊢i p $ C.[□↦A] ---> p $ C.[□↦B] using i
    -
Σ: Signature
Γ: Theory
A, B: Pattern
i: ProofInfo
pile: ProofInfoLe
  (ExGen := ∅, SVSubst := ∅, KT := false) i
WFA: well_formed A
WFB: well_formed B
H: Γ ⊢i A ---> B using i
Γ ⊢i A ---> B using i exact H.
    -
Σ: Signature
Γ: Theory
C: Application_context
p: Pattern
Prf: well_formed p
A, B: Pattern
i: ProofInfo
pile: ProofInfoLe
  (ExGen := ∅, SVSubst := ∅, KT := false) i
IHC: well_formed A
→ well_formed B
  → Γ ⊢i A ---> B using i
    → Γ ⊢i C.[□↦A] ---> C.[□↦B] using i
WFA: well_formed A
WFB: well_formed B
H: Γ ⊢i A ---> B using i
Γ ⊢i C.[□↦A] $ p ---> C.[□↦B] $ p using i destruct i.
Σ: Signature
Γ: Theory
C: Application_context
p: Pattern
Prf: well_formed p
A, B: Pattern
pi_generalized_evars: coEVarSet
pi_substituted_svars: coSVarSet
pi_uses_kt: bool
pile: ProofInfoLe
  (ExGen := ∅, SVSubst := ∅, KT := false)
  (ExGen := pi_generalized_evars,
   SVSubst := pi_substituted_svars,
   KT := pi_uses_kt)
IHC: well_formed A
→ well_formed B
  → Γ ⊢i A ---> B
    using (ExGen := pi_generalized_evars,
           SVSubst := pi_substituted_svars,
           KT := pi_uses_kt)
    → Γ ⊢i C.[□↦A] ---> C.[□↦B]
      using (ExGen := pi_generalized_evars,
             SVSubst := pi_substituted_svars,
             KT := pi_uses_kt)
WFA: well_formed A
WFB: well_formed B
H: Γ ⊢i A ---> B
using (ExGen := pi_generalized_evars,
       SVSubst := pi_substituted_svars,
       KT := pi_uses_kt)
Γ ⊢i C.[□↦A] $ p ---> C.[□↦B] $ p
using (ExGen := pi_generalized_evars,
       SVSubst := pi_substituted_svars,
       KT := pi_uses_kt)
      unshelve (eapply (Framing_left _ _ _ _ _ Prf)).
Σ: Signature
Γ: Theory
C: Application_context
p: Pattern
Prf: well_formed p
A, B: Pattern
pi_generalized_evars: coEVarSet
pi_substituted_svars: coSVarSet
pi_uses_kt: bool
pile: ProofInfoLe
  (ExGen := ∅, SVSubst := ∅, KT := false)
  (ExGen := pi_generalized_evars,
   SVSubst := pi_substituted_svars,
   KT := pi_uses_kt)
IHC: well_formed A
→ well_formed B
  → Γ ⊢i A ---> B
    using (ExGen := pi_generalized_evars,
           SVSubst := pi_substituted_svars,
           KT := pi_uses_kt)
    → Γ ⊢i C.[□↦A] ---> C.[□↦B]
      using (ExGen := pi_generalized_evars,
             SVSubst := pi_substituted_svars,
             KT := pi_uses_kt)
WFA: well_formed A
WFB: well_formed B
H: Γ ⊢i A ---> B
using (ExGen := pi_generalized_evars,
       SVSubst := pi_substituted_svars,
       KT := pi_uses_kt)
ProofInfoLe (ExGen := ∅, SVSubst := ∅, KT := false)
  (ExGen := pi_generalized_evars,
   SVSubst := pi_substituted_svars, KT := pi_uses_kt)
Σ: Signature
Γ: Theory
C: Application_context
p: Pattern
Prf: well_formed p
A, B: Pattern
pi_generalized_evars: coEVarSet
pi_substituted_svars: coSVarSet
pi_uses_kt: bool
pile: ProofInfoLe
  (ExGen := ∅, SVSubst := ∅, KT := false)
  (ExGen := pi_generalized_evars,
   SVSubst := pi_substituted_svars,
   KT := pi_uses_kt)
IHC: well_formed A
→ well_formed B
  → Γ ⊢i A ---> B
    using (ExGen := pi_generalized_evars,
           SVSubst := pi_substituted_svars,
           KT := pi_uses_kt)
    → Γ ⊢i C.[□↦A] ---> C.[□↦B]
      using (ExGen := pi_generalized_evars,
             SVSubst := pi_substituted_svars,
             KT := pi_uses_kt)
WFA: well_formed A
WFB: well_formed B
H: Γ ⊢i A ---> B
using (ExGen := pi_generalized_evars,
       SVSubst := pi_substituted_svars,
       KT := pi_uses_kt)
Γ ⊢i C.[□↦A] ---> C.[□↦B]
using (ExGen := pi_generalized_evars,
       SVSubst := pi_substituted_svars,
       KT := pi_uses_kt)
      {
Σ: Signature
Γ: Theory
C: Application_context
p: Pattern
Prf: well_formed p
A, B: Pattern
pi_generalized_evars: coEVarSet
pi_substituted_svars: coSVarSet
pi_uses_kt: bool
pile: ProofInfoLe
  (ExGen := ∅, SVSubst := ∅, KT := false)
  (ExGen := pi_generalized_evars,
   SVSubst := pi_substituted_svars,
   KT := pi_uses_kt)
IHC: well_formed A
→ well_formed B
  → Γ ⊢i A ---> B
    using (ExGen := pi_generalized_evars,
           SVSubst := pi_substituted_svars,
           KT := pi_uses_kt)
    → Γ ⊢i C.[□↦A] ---> C.[□↦B]
      using (ExGen := pi_generalized_evars,
             SVSubst := pi_substituted_svars,
             KT := pi_uses_kt)
WFA: well_formed A
WFB: well_formed B
H: Γ ⊢i A ---> B
using (ExGen := pi_generalized_evars,
       SVSubst := pi_substituted_svars,
       KT := pi_uses_kt)
ProofInfoLe (ExGen := ∅, SVSubst := ∅, KT := false)
  (ExGen := pi_generalized_evars,
   SVSubst := pi_substituted_svars, KT := pi_uses_kt) 
        try_solve_pile.
      }
Σ: Signature
Γ: Theory
C: Application_context
p: Pattern
Prf: well_formed p
A, B: Pattern
pi_generalized_evars: coEVarSet
pi_substituted_svars: coSVarSet
pi_uses_kt: bool
pile: ProofInfoLe
  (ExGen := ∅, SVSubst := ∅, KT := false)
  (ExGen := pi_generalized_evars,
   SVSubst := pi_substituted_svars,
   KT := pi_uses_kt)
IHC: well_formed A
→ well_formed B
  → Γ ⊢i A ---> B
    using (ExGen := pi_generalized_evars,
           SVSubst := pi_substituted_svars,
           KT := pi_uses_kt)
    → Γ ⊢i C.[□↦A] ---> C.[□↦B]
      using (ExGen := pi_generalized_evars,
             SVSubst := pi_substituted_svars,
             KT := pi_uses_kt)
WFA: well_formed A
WFB: well_formed B
H: Γ ⊢i A ---> B
using (ExGen := pi_generalized_evars,
       SVSubst := pi_substituted_svars,
       KT := pi_uses_kt)
Γ ⊢i C.[□↦A] ---> C.[□↦B]
using (ExGen := pi_generalized_evars,
       SVSubst := pi_substituted_svars,
       KT := pi_uses_kt)
      apply IHC.
Σ: Signature
Γ: Theory
C: Application_context
p: Pattern
Prf: well_formed p
A, B: Pattern
pi_generalized_evars: coEVarSet
pi_substituted_svars: coSVarSet
pi_uses_kt: bool
pile: ProofInfoLe
  (ExGen := ∅, SVSubst := ∅, KT := false)
  (ExGen := pi_generalized_evars,
   SVSubst := pi_substituted_svars,
   KT := pi_uses_kt)
IHC: well_formed A
→ well_formed B
  → Γ ⊢i A ---> B
    using (ExGen := pi_generalized_evars,
           SVSubst := pi_substituted_svars,
           KT := pi_uses_kt)
    → Γ ⊢i C.[□↦A] ---> C.[□↦B]
      using (ExGen := pi_generalized_evars,
             SVSubst := pi_substituted_svars,
             KT := pi_uses_kt)
WFA: well_formed A
WFB: well_formed B
H: Γ ⊢i A ---> B
using (ExGen := pi_generalized_evars,
       SVSubst := pi_substituted_svars,
       KT := pi_uses_kt)
well_formed A
Σ: Signature
Γ: Theory
C: Application_context
p: Pattern
Prf: well_formed p
A, B: Pattern
pi_generalized_evars: coEVarSet
pi_substituted_svars: coSVarSet
pi_uses_kt: bool
pile: ProofInfoLe
  (ExGen := ∅, SVSubst := ∅, KT := false)
  (ExGen := pi_generalized_evars,
   SVSubst := pi_substituted_svars,
   KT := pi_uses_kt)
IHC: well_formed A
→ well_formed B
  → Γ ⊢i A ---> B
    using (ExGen := pi_generalized_evars,
           SVSubst := pi_substituted_svars,
           KT := pi_uses_kt)
    → Γ ⊢i C.[□↦A] ---> C.[□↦B]
      using (ExGen := pi_generalized_evars,
             SVSubst := pi_substituted_svars,
             KT := pi_uses_kt)
WFA: well_formed A
WFB: well_formed B
H: Γ ⊢i A ---> B
using (ExGen := pi_generalized_evars,
       SVSubst := pi_substituted_svars,
       KT := pi_uses_kt)
well_formed B
Σ: Signature
Γ: Theory
C: Application_context
p: Pattern
Prf: well_formed p
A, B: Pattern
pi_generalized_evars: coEVarSet
pi_substituted_svars: coSVarSet
pi_uses_kt: bool
pile: ProofInfoLe
  (ExGen := ∅, SVSubst := ∅, KT := false)
  (ExGen := pi_generalized_evars,
   SVSubst := pi_substituted_svars,
   KT := pi_uses_kt)
IHC: well_formed A
→ well_formed B
  → Γ ⊢i A ---> B
    using (ExGen := pi_generalized_evars,
           SVSubst := pi_substituted_svars,
           KT := pi_uses_kt)
    → Γ ⊢i C.[□↦A] ---> C.[□↦B]
      using (ExGen := pi_generalized_evars,
             SVSubst := pi_substituted_svars,
             KT := pi_uses_kt)
WFA: well_formed A
WFB: well_formed B
H: Γ ⊢i A ---> B
using (ExGen := pi_generalized_evars,
       SVSubst := pi_substituted_svars,
       KT := pi_uses_kt)
Γ ⊢i A ---> B
using (ExGen := pi_generalized_evars,
       SVSubst := pi_substituted_svars,
       KT := pi_uses_kt)
      1-3: assumption.
    -
Σ: Signature
Γ: Theory
p: Pattern
C: Application_context
Prf: well_formed p
A, B: Pattern
i: ProofInfo
pile: ProofInfoLe
  (ExGen := ∅, SVSubst := ∅, KT := false) i
IHC: well_formed A
→ well_formed B
  → Γ ⊢i A ---> B using i
    → Γ ⊢i C.[□↦A] ---> C.[□↦B] using i
WFA: well_formed A
WFB: well_formed B
H: Γ ⊢i A ---> B using i
Γ ⊢i p $ C.[□↦A] ---> p $ C.[□↦B] using i destruct i.
Σ: Signature
Γ: Theory
p: Pattern
C: Application_context
Prf: well_formed p
A, B: Pattern
pi_generalized_evars: coEVarSet
pi_substituted_svars: coSVarSet
pi_uses_kt: bool
pile: ProofInfoLe
  (ExGen := ∅, SVSubst := ∅, KT := false)
  (ExGen := pi_generalized_evars,
   SVSubst := pi_substituted_svars,
   KT := pi_uses_kt)
IHC: well_formed A
→ well_formed B
  → Γ ⊢i A ---> B
    using (ExGen := pi_generalized_evars,
           SVSubst := pi_substituted_svars,
           KT := pi_uses_kt)
    → Γ ⊢i C.[□↦A] ---> C.[□↦B]
      using (ExGen := pi_generalized_evars,
             SVSubst := pi_substituted_svars,
             KT := pi_uses_kt)
WFA: well_formed A
WFB: well_formed B
H: Γ ⊢i A ---> B
using (ExGen := pi_generalized_evars,
       SVSubst := pi_substituted_svars,
       KT := pi_uses_kt)
Γ ⊢i p $ C.[□↦A] ---> p $ C.[□↦B]
using (ExGen := pi_generalized_evars,
       SVSubst := pi_substituted_svars,
       KT := pi_uses_kt)
      unshelve (eapply (Framing_right _ _ _ _ _ Prf)).
Σ: Signature
Γ: Theory
p: Pattern
C: Application_context
Prf: well_formed p
A, B: Pattern
pi_generalized_evars: coEVarSet
pi_substituted_svars: coSVarSet
pi_uses_kt: bool
pile: ProofInfoLe
  (ExGen := ∅, SVSubst := ∅, KT := false)
  (ExGen := pi_generalized_evars,
   SVSubst := pi_substituted_svars,
   KT := pi_uses_kt)
IHC: well_formed A
→ well_formed B
  → Γ ⊢i A ---> B
    using (ExGen := pi_generalized_evars,
           SVSubst := pi_substituted_svars,
           KT := pi_uses_kt)
    → Γ ⊢i C.[□↦A] ---> C.[□↦B]
      using (ExGen := pi_generalized_evars,
             SVSubst := pi_substituted_svars,
             KT := pi_uses_kt)
WFA: well_formed A
WFB: well_formed B
H: Γ ⊢i A ---> B
using (ExGen := pi_generalized_evars,
       SVSubst := pi_substituted_svars,
       KT := pi_uses_kt)
ProofInfoLe (ExGen := ∅, SVSubst := ∅, KT := false)
  (ExGen := pi_generalized_evars,
   SVSubst := pi_substituted_svars, KT := pi_uses_kt)
Σ: Signature
Γ: Theory
p: Pattern
C: Application_context
Prf: well_formed p
A, B: Pattern
pi_generalized_evars: coEVarSet
pi_substituted_svars: coSVarSet
pi_uses_kt: bool
pile: ProofInfoLe
  (ExGen := ∅, SVSubst := ∅, KT := false)
  (ExGen := pi_generalized_evars,
   SVSubst := pi_substituted_svars,
   KT := pi_uses_kt)
IHC: well_formed A
→ well_formed B
  → Γ ⊢i A ---> B
    using (ExGen := pi_generalized_evars,
           SVSubst := pi_substituted_svars,
           KT := pi_uses_kt)
    → Γ ⊢i C.[□↦A] ---> C.[□↦B]
      using (ExGen := pi_generalized_evars,
             SVSubst := pi_substituted_svars,
             KT := pi_uses_kt)
WFA: well_formed A
WFB: well_formed B
H: Γ ⊢i A ---> B
using (ExGen := pi_generalized_evars,
       SVSubst := pi_substituted_svars,
       KT := pi_uses_kt)
Γ ⊢i C.[□↦A] ---> C.[□↦B]
using (ExGen := pi_generalized_evars,
       SVSubst := pi_substituted_svars,
       KT := pi_uses_kt)
      {
Σ: Signature
Γ: Theory
p: Pattern
C: Application_context
Prf: well_formed p
A, B: Pattern
pi_generalized_evars: coEVarSet
pi_substituted_svars: coSVarSet
pi_uses_kt: bool
pile: ProofInfoLe
  (ExGen := ∅, SVSubst := ∅, KT := false)
  (ExGen := pi_generalized_evars,
   SVSubst := pi_substituted_svars,
   KT := pi_uses_kt)
IHC: well_formed A
→ well_formed B
  → Γ ⊢i A ---> B
    using (ExGen := pi_generalized_evars,
           SVSubst := pi_substituted_svars,
           KT := pi_uses_kt)
    → Γ ⊢i C.[□↦A] ---> C.[□↦B]
      using (ExGen := pi_generalized_evars,
             SVSubst := pi_substituted_svars,
             KT := pi_uses_kt)
WFA: well_formed A
WFB: well_formed B
H: Γ ⊢i A ---> B
using (ExGen := pi_generalized_evars,
       SVSubst := pi_substituted_svars,
       KT := pi_uses_kt)
ProofInfoLe (ExGen := ∅, SVSubst := ∅, KT := false)
  (ExGen := pi_generalized_evars,
   SVSubst := pi_substituted_svars, KT := pi_uses_kt)
        try_solve_pile.
      }
Σ: Signature
Γ: Theory
p: Pattern
C: Application_context
Prf: well_formed p
A, B: Pattern
pi_generalized_evars: coEVarSet
pi_substituted_svars: coSVarSet
pi_uses_kt: bool
pile: ProofInfoLe
  (ExGen := ∅, SVSubst := ∅, KT := false)
  (ExGen := pi_generalized_evars,
   SVSubst := pi_substituted_svars,
   KT := pi_uses_kt)
IHC: well_formed A
→ well_formed B
  → Γ ⊢i A ---> B
    using (ExGen := pi_generalized_evars,
           SVSubst := pi_substituted_svars,
           KT := pi_uses_kt)
    → Γ ⊢i C.[□↦A] ---> C.[□↦B]
      using (ExGen := pi_generalized_evars,
             SVSubst := pi_substituted_svars,
             KT := pi_uses_kt)
WFA: well_formed A
WFB: well_formed B
H: Γ ⊢i A ---> B
using (ExGen := pi_generalized_evars,
       SVSubst := pi_substituted_svars,
       KT := pi_uses_kt)
Γ ⊢i C.[□↦A] ---> C.[□↦B]
using (ExGen := pi_generalized_evars,
       SVSubst := pi_substituted_svars,
       KT := pi_uses_kt)
      apply IHC.
Σ: Signature
Γ: Theory
p: Pattern
C: Application_context
Prf: well_formed p
A, B: Pattern
pi_generalized_evars: coEVarSet
pi_substituted_svars: coSVarSet
pi_uses_kt: bool
pile: ProofInfoLe
  (ExGen := ∅, SVSubst := ∅, KT := false)
  (ExGen := pi_generalized_evars,
   SVSubst := pi_substituted_svars,
   KT := pi_uses_kt)
IHC: well_formed A
→ well_formed B
  → Γ ⊢i A ---> B
    using (ExGen := pi_generalized_evars,
           SVSubst := pi_substituted_svars,
           KT := pi_uses_kt)
    → Γ ⊢i C.[□↦A] ---> C.[□↦B]
      using (ExGen := pi_generalized_evars,
             SVSubst := pi_substituted_svars,
             KT := pi_uses_kt)
WFA: well_formed A
WFB: well_formed B
H: Γ ⊢i A ---> B
using (ExGen := pi_generalized_evars,
       SVSubst := pi_substituted_svars,
       KT := pi_uses_kt)
well_formed A
Σ: Signature
Γ: Theory
p: Pattern
C: Application_context
Prf: well_formed p
A, B: Pattern
pi_generalized_evars: coEVarSet
pi_substituted_svars: coSVarSet
pi_uses_kt: bool
pile: ProofInfoLe
  (ExGen := ∅, SVSubst := ∅, KT := false)
  (ExGen := pi_generalized_evars,
   SVSubst := pi_substituted_svars,
   KT := pi_uses_kt)
IHC: well_formed A
→ well_formed B
  → Γ ⊢i A ---> B
    using (ExGen := pi_generalized_evars,
           SVSubst := pi_substituted_svars,
           KT := pi_uses_kt)
    → Γ ⊢i C.[□↦A] ---> C.[□↦B]
      using (ExGen := pi_generalized_evars,
             SVSubst := pi_substituted_svars,
             KT := pi_uses_kt)
WFA: well_formed A
WFB: well_formed B
H: Γ ⊢i A ---> B
using (ExGen := pi_generalized_evars,
       SVSubst := pi_substituted_svars,
       KT := pi_uses_kt)
well_formed B
Σ: Signature
Γ: Theory
p: Pattern
C: Application_context
Prf: well_formed p
A, B: Pattern
pi_generalized_evars: coEVarSet
pi_substituted_svars: coSVarSet
pi_uses_kt: bool
pile: ProofInfoLe
  (ExGen := ∅, SVSubst := ∅, KT := false)
  (ExGen := pi_generalized_evars,
   SVSubst := pi_substituted_svars,
   KT := pi_uses_kt)
IHC: well_formed A
→ well_formed B
  → Γ ⊢i A ---> B
    using (ExGen := pi_generalized_evars,
           SVSubst := pi_substituted_svars,
           KT := pi_uses_kt)
    → Γ ⊢i C.[□↦A] ---> C.[□↦B]
      using (ExGen := pi_generalized_evars,
             SVSubst := pi_substituted_svars,
             KT := pi_uses_kt)
WFA: well_formed A
WFB: well_formed B
H: Γ ⊢i A ---> B
using (ExGen := pi_generalized_evars,
       SVSubst := pi_substituted_svars,
       KT := pi_uses_kt)
Γ ⊢i A ---> B
using (ExGen := pi_generalized_evars,
       SVSubst := pi_substituted_svars,
       KT := pi_uses_kt)
      1-3: assumption.
  Defined.

  Lemma A_implies_not_not_A_ctx (Γ : Theory) (A : Pattern) (C : Application_context)
    (i : ProofInfo) {pile : ProofInfoLe ((ExGen := ∅, SVSubst := ∅, KT := false)) i}
    :
    well_formed A ->
    Γ ⊢i A using i ->
    Γ ⊢i (! (subst_ctx C ( !A ))) using i.
Σ: Signature
Γ: Theory
A: Pattern
C: Application_context
i: ProofInfo
pile: ProofInfoLe
  (ExGen := ∅, SVSubst := ∅, KT := false) i
well_formed A
→ Γ ⊢i A using i → Γ ⊢i ! C.[□↦! A] using i
  Proof.
Σ: Signature
Γ: Theory
A: Pattern
C: Application_context
i: ProofInfo
pile: ProofInfoLe
  (ExGen := ∅, SVSubst := ∅, KT := false) i
well_formed A
→ Γ ⊢i A using i → Γ ⊢i ! C.[□↦! A] using i
    intros WFA H.
Σ: Signature
Γ: Theory
A: Pattern
C: Application_context
i: ProofInfo
pile: ProofInfoLe
  (ExGen := ∅, SVSubst := ∅, KT := false) i
WFA: well_formed A
H: Γ ⊢i A using i
Γ ⊢i ! C.[□↦! A] using i

    epose proof (ANNA := A_implies_not_not_A_alt Γ _ i _ H).
Σ: Signature
Γ: Theory
A: Pattern
C: Application_context
i: ProofInfo
pile: ProofInfoLe
  (ExGen := ∅, SVSubst := ∅, KT := false) i
WFA: well_formed A
H: Γ ⊢i A using i
ANNA: Γ ⊢i ! ! A using i
Γ ⊢i ! C.[□↦! A] using i
    replace (! (! A)) with ((! A) ---> Bot) in ANNA by reflexivity.
Σ: Signature
Γ: Theory
A: Pattern
C: Application_context
i: ProofInfo
pile: ProofInfoLe
  (ExGen := ∅, SVSubst := ∅, KT := false) i
WFA: well_formed A
H: Γ ⊢i A using i
ANNA: Γ ⊢i ! A ---> ⊥ using i
Γ ⊢i ! C.[□↦! A] using i
    epose proof (EF := Framing _ C (! A) Bot _ ANNA).
Σ: Signature
Γ: Theory
A: Pattern
C: Application_context
i: ProofInfo
pile: ProofInfoLe
  (ExGen := ∅, SVSubst := ∅, KT := false) i
WFA: well_formed A
H: Γ ⊢i A using i
ANNA: Γ ⊢i ! A ---> ⊥ using i
EF: Γ ⊢i C.[□↦! A] ---> C.[□↦⊥] using i
Γ ⊢i ! C.[□↦! A] using i
    epose proof (PB := Prop_bot_ctx Γ C).
Σ: Signature
Γ: Theory
A: Pattern
C: Application_context
i: ProofInfo
pile: ProofInfoLe
  (ExGen := ∅, SVSubst := ∅, KT := false) i
WFA: well_formed A
H: Γ ⊢i A using i
ANNA: Γ ⊢i ! A ---> ⊥ using i
EF: Γ ⊢i C.[□↦! A] ---> C.[□↦⊥] using i
PB: Γ ⊢i C.[□↦⊥] ---> ⊥
using (ExGen := ∅, SVSubst := ∅, KT := false)
Γ ⊢i ! C.[□↦! A] using i
    apply liftProofInfoLe with (i₂ := i) in PB.
Σ: Signature
Γ: Theory
A: Pattern
C: Application_context
i: ProofInfo
pile: ProofInfoLe
  (ExGen := ∅, SVSubst := ∅, KT := false) i
WFA: well_formed A
H: Γ ⊢i A using i
ANNA: Γ ⊢i ! A ---> ⊥ using i
EF: Γ ⊢i C.[□↦! A] ---> C.[□↦⊥] using i
PB: Γ ⊢i C.[□↦⊥] ---> ⊥ using i
Γ ⊢i ! C.[□↦! A] using i
Σ: Signature
Γ: Theory
A: Pattern
C: Application_context
i: ProofInfo
pile: ProofInfoLe
  (ExGen := ∅, SVSubst := ∅, KT := false) i
WFA: well_formed A
H: Γ ⊢i A using i
ANNA: Γ ⊢i ! A ---> ⊥ using i
EF: Γ ⊢i C.[□↦! A] ---> C.[□↦⊥] using i
PB: Γ ⊢i C.[□↦⊥] ---> ⊥
using (ExGen := ∅, SVSubst := ∅, KT := false)
ProofInfoLe (ExGen := ∅, SVSubst := ∅, KT := false) i 2: try_solve_pile.
Σ: Signature
Γ: Theory
A: Pattern
C: Application_context
i: ProofInfo
pile: ProofInfoLe
  (ExGen := ∅, SVSubst := ∅, KT := false) i
WFA: well_formed A
H: Γ ⊢i A using i
ANNA: Γ ⊢i ! A ---> ⊥ using i
EF: Γ ⊢i C.[□↦! A] ---> C.[□↦⊥] using i
PB: Γ ⊢i C.[□↦⊥] ---> ⊥ using i
Γ ⊢i ! C.[□↦! A] using i
    epose (TRANS := syllogism_meta _ _ _ EF PB).
Σ: Signature
Γ: Theory
A: Pattern
C: Application_context
i: ProofInfo
pile: ProofInfoLe
  (ExGen := ∅, SVSubst := ∅, KT := false) i
WFA: well_formed A
H: Γ ⊢i A using i
ANNA: Γ ⊢i ! A ---> ⊥ using i
EF: Γ ⊢i C.[□↦! A] ---> C.[□↦⊥] using i
PB: Γ ⊢i C.[□↦⊥] ---> ⊥ using i
TRANS:= syllogism_meta ?Goal0 ?Goal1 ?Goal2 EF PB: Γ ⊢i C.[□↦! A] ---> ⊥ using i
Γ ⊢i ! C.[□↦! A] using i
    apply TRANS.

    Unshelve.
Σ: Signature
Γ: Theory
A: Pattern
C: Application_context
i: ProofInfo
pile: ProofInfoLe
  (ExGen := ∅, SVSubst := ∅, KT := false) i
WFA: well_formed A
H: Γ ⊢i A using i
well_formed A
Σ: Signature
Γ: Theory
A: Pattern
C: Application_context
i: ProofInfo
pile: ProofInfoLe
  (ExGen := ∅, SVSubst := ∅, KT := false) i
WFA: well_formed A
H: Γ ⊢i A using i
ANNA: Γ ⊢i ! A ---> ⊥ using i
ProofInfoLe (ExGen := ∅, SVSubst := ∅, KT := false) i
Σ: Signature
Γ: Theory
A: Pattern
C: Application_context
i: ProofInfo
pile: ProofInfoLe
  (ExGen := ∅, SVSubst := ∅, KT := false) i
WFA: well_formed A
H: Γ ⊢i A using i
ANNA: Γ ⊢i ! A ---> ⊥ using i
EF: Γ ⊢i C.[□↦! A] ---> C.[□↦⊥] using i
PB: Γ ⊢i C.[□↦⊥] ---> ⊥ using i
well_formed C.[□↦! A]
Σ: Signature
Γ: Theory
A: Pattern
C: Application_context
i: ProofInfo
pile: ProofInfoLe
  (ExGen := ∅, SVSubst := ∅, KT := false) i
WFA: well_formed A
H: Γ ⊢i A using i
ANNA: Γ ⊢i ! A ---> ⊥ using i
EF: Γ ⊢i C.[□↦! A] ---> C.[□↦⊥] using i
PB: Γ ⊢i C.[□↦⊥] ---> ⊥ using i
well_formed C.[□↦⊥]
Σ: Signature
Γ: Theory
A: Pattern
C: Application_context
i: ProofInfo
pile: ProofInfoLe
  (ExGen := ∅, SVSubst := ∅, KT := false) i
WFA: well_formed A
H: Γ ⊢i A using i
ANNA: Γ ⊢i ! A ---> ⊥ using i
EF: Γ ⊢i C.[□↦! A] ---> C.[□↦⊥] using i
PB: Γ ⊢i C.[□↦⊥] ---> ⊥ using i
well_formed ⊥
    all: wf_auto2.
Σ: Signature
Γ: Theory
A: Pattern
C: Application_context
i: ProofInfo
H2: true = true
H0: well_formed_positive A = true
H1: well_formed_closed_ex_aux A 0 = true
H4: well_formed_closed_mu_aux A 0 = true
∅ ⊆ pi_generalized_evars i
Σ: Signature
Γ: Theory
A: Pattern
C: Application_context
i: ProofInfo
H2: true = true
H0: well_formed_positive A = true
H1: well_formed_closed_ex_aux A 0 = true
H4: well_formed_closed_mu_aux A 0 = true
∅ ⊆ pi_substituted_svars i
    all: set_solver.
  Defined.

  Lemma ctx_bot_prop (Γ : Theory) (C : Application_context) (A : Pattern) 
    (i : ProofInfo)
    {pile : ProofInfoLe ((ExGen := ∅, SVSubst := ∅, KT := false)) i}
  :
    well_formed A ->
    Γ ⊢i (A ---> Bot) using i ->
    Γ ⊢i (subst_ctx C A ---> Bot) using i.
Σ: Signature
Γ: Theory
C: Application_context
A: Pattern
i: ProofInfo
pile: ProofInfoLe
  (ExGen := ∅, SVSubst := ∅, KT := false) i
well_formed A
→ Γ ⊢i A ---> ⊥ using i → Γ ⊢i C.[□↦A] ---> ⊥ using i
  Proof.
Σ: Signature
Γ: Theory
C: Application_context
A: Pattern
i: ProofInfo
pile: ProofInfoLe
  (ExGen := ∅, SVSubst := ∅, KT := false) i
well_formed A
→ Γ ⊢i A ---> ⊥ using i → Γ ⊢i C.[□↦A] ---> ⊥ using i
    intros WFA H.
Σ: Signature
Γ: Theory
C: Application_context
A: Pattern
i: ProofInfo
pile: ProofInfoLe
  (ExGen := ∅, SVSubst := ∅, KT := false) i
WFA: well_formed A
H: Γ ⊢i A ---> ⊥ using i
Γ ⊢i C.[□↦A] ---> ⊥ using i
    epose proof (FR := Framing Γ C A Bot _ H).
Σ: Signature
Γ: Theory
C: Application_context
A: Pattern
i: ProofInfo
pile: ProofInfoLe
  (ExGen := ∅, SVSubst := ∅, KT := false) i
WFA: well_formed A
H: Γ ⊢i A ---> ⊥ using i
FR: Γ ⊢i C.[□↦A] ---> C.[□↦⊥] using i
Γ ⊢i C.[□↦A] ---> ⊥ using i
    epose proof (BPR := Prop_bot_ctx Γ C).
Σ: Signature
Γ: Theory
C: Application_context
A: Pattern
i: ProofInfo
pile: ProofInfoLe
  (ExGen := ∅, SVSubst := ∅, KT := false) i
WFA: well_formed A
H: Γ ⊢i A ---> ⊥ using i
FR: Γ ⊢i C.[□↦A] ---> C.[□↦⊥] using i
BPR: Γ ⊢i C.[□↦⊥] ---> ⊥
using (ExGen := ∅, SVSubst := ∅, KT := false)
Γ ⊢i C.[□↦A] ---> ⊥ using i
    apply liftProofInfoLe with (i₂ := i) in BPR.
Σ: Signature
Γ: Theory
C: Application_context
A: Pattern
i: ProofInfo
pile: ProofInfoLe
  (ExGen := ∅, SVSubst := ∅, KT := false) i
WFA: well_formed A
H: Γ ⊢i A ---> ⊥ using i
FR: Γ ⊢i C.[□↦A] ---> C.[□↦⊥] using i
BPR: Γ ⊢i C.[□↦⊥] ---> ⊥ using i
Γ ⊢i C.[□↦A] ---> ⊥ using i
Σ: Signature
Γ: Theory
C: Application_context
A: Pattern
i: ProofInfo
pile: ProofInfoLe
  (ExGen := ∅, SVSubst := ∅, KT := false) i
WFA: well_formed A
H: Γ ⊢i A ---> ⊥ using i
FR: Γ ⊢i C.[□↦A] ---> C.[□↦⊥] using i
BPR: Γ ⊢i C.[□↦⊥] ---> ⊥
using (ExGen := ∅, SVSubst := ∅, KT := false)
ProofInfoLe (ExGen := ∅, SVSubst := ∅, KT := false) i 2: try_solve_pile.
Σ: Signature
Γ: Theory
C: Application_context
A: Pattern
i: ProofInfo
pile: ProofInfoLe
  (ExGen := ∅, SVSubst := ∅, KT := false) i
WFA: well_formed A
H: Γ ⊢i A ---> ⊥ using i
FR: Γ ⊢i C.[□↦A] ---> C.[□↦⊥] using i
BPR: Γ ⊢i C.[□↦⊥] ---> ⊥ using i
Γ ⊢i C.[□↦A] ---> ⊥ using i
    epose proof (TRANS := syllogism_meta _ _ _ FR BPR).
Σ: Signature
Γ: Theory
C: Application_context
A: Pattern
i: ProofInfo
pile: ProofInfoLe
  (ExGen := ∅, SVSubst := ∅, KT := false) i
WFA: well_formed A
H: Γ ⊢i A ---> ⊥ using i
FR: Γ ⊢i C.[□↦A] ---> C.[□↦⊥] using i
BPR: Γ ⊢i C.[□↦⊥] ---> ⊥ using i
TRANS: Γ ⊢i C.[□↦A] ---> ⊥ using i
Γ ⊢i C.[□↦A] ---> ⊥ using i
    exact TRANS.
    Unshelve.
Σ: Signature
Γ: Theory
C: Application_context
A: Pattern
i: ProofInfo
pile: ProofInfoLe
  (ExGen := ∅, SVSubst := ∅, KT := false) i
WFA: well_formed A
H: Γ ⊢i A ---> ⊥ using i
ProofInfoLe (ExGen := ∅, SVSubst := ∅, KT := false) i
Σ: Signature
Γ: Theory
C: Application_context
A: Pattern
i: ProofInfo
pile: ProofInfoLe
  (ExGen := ∅, SVSubst := ∅, KT := false) i
WFA: well_formed A
H: Γ ⊢i A ---> ⊥ using i
FR: Γ ⊢i C.[□↦A] ---> C.[□↦⊥] using i
BPR: Γ ⊢i C.[□↦⊥] ---> ⊥ using i
well_formed C.[□↦A]
Σ: Signature
Γ: Theory
C: Application_context
A: Pattern
i: ProofInfo
pile: ProofInfoLe
  (ExGen := ∅, SVSubst := ∅, KT := false) i
WFA: well_formed A
H: Γ ⊢i A ---> ⊥ using i
FR: Γ ⊢i C.[□↦A] ---> C.[□↦⊥] using i
BPR: Γ ⊢i C.[□↦⊥] ---> ⊥ using i
well_formed C.[□↦⊥]
Σ: Signature
Γ: Theory
C: Application_context
A: Pattern
i: ProofInfo
pile: ProofInfoLe
  (ExGen := ∅, SVSubst := ∅, KT := false) i
WFA: well_formed A
H: Γ ⊢i A ---> ⊥ using i
FR: Γ ⊢i C.[□↦A] ---> C.[□↦⊥] using i
BPR: Γ ⊢i C.[□↦⊥] ---> ⊥ using i
well_formed ⊥
    all: wf_auto2.
Σ: Signature
Γ: Theory
C: Application_context
A: Pattern
i: ProofInfo
H2: true = true
H1: well_formed_positive A = true
H3: well_formed_closed_ex_aux A 0 = true
H0: well_formed_closed_mu_aux A 0 = true
∅ ⊆ pi_generalized_evars i
Σ: Signature
Γ: Theory
C: Application_context
A: Pattern
i: ProofInfo
H2: true = true
H1: well_formed_positive A = true
H3: well_formed_closed_ex_aux A 0 = true
H0: well_formed_closed_mu_aux A 0 = true
∅ ⊆ pi_substituted_svars i
    all: set_solver.
  Defined.

End FOL_helpers.

Lemma prf_prop_bott_iff {Σ : Signature} Γ AC:
  Γ ⊢i ((subst_ctx AC patt_bott) <---> patt_bott)
  using (
  (ExGen := ∅, SVSubst := ∅, KT := false)).
Σ: Signature
Γ: Theory
AC: Application_context
Γ ⊢i AC.[□↦⊥] <---> ⊥
using (ExGen := ∅, SVSubst := ∅, KT := false)
Proof.
Σ: Signature
Γ: Theory
AC: Application_context
Γ ⊢i AC.[□↦⊥] <---> ⊥
using (ExGen := ∅, SVSubst := ∅, KT := false)
  apply pf_iff_split.
Σ: Signature
Γ: Theory
AC: Application_context
well_formed AC.[□↦⊥]
Σ: Signature
Γ: Theory
AC: Application_context
well_formed ⊥
Σ: Signature
Γ: Theory
AC: Application_context
Γ ⊢i AC.[□↦⊥] ---> ⊥
using (ExGen := ∅, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
AC: Application_context
Γ ⊢i ⊥ ---> AC.[□↦⊥]
using (ExGen := ∅, SVSubst := ∅, KT := false)
  1,2: wf_auto2.
Σ: Signature
Γ: Theory
AC: Application_context
Γ ⊢i AC.[□↦⊥] ---> ⊥
using (ExGen := ∅, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
AC: Application_context
Γ ⊢i ⊥ ---> AC.[□↦⊥]
using (ExGen := ∅, SVSubst := ∅, KT := false)
  1: apply ctx_bot_prop.
Σ: Signature
Γ: Theory
AC: Application_context
ProofInfoLe (ExGen := ∅, SVSubst := ∅, KT := false)
  (ExGen := ∅, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
AC: Application_context
well_formed ⊥
Σ: Signature
Γ: Theory
AC: Application_context
Γ ⊢i ⊥ ---> ⊥
using (ExGen := ∅, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
AC: Application_context
Γ ⊢i ⊥ ---> AC.[□↦⊥]
using (ExGen := ∅, SVSubst := ∅, KT := false)
  1: apply pile_refl.
Σ: Signature
Γ: Theory
AC: Application_context
well_formed ⊥
Σ: Signature
Γ: Theory
AC: Application_context
Γ ⊢i ⊥ ---> ⊥
using (ExGen := ∅, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
AC: Application_context
Γ ⊢i ⊥ ---> AC.[□↦⊥]
using (ExGen := ∅, SVSubst := ∅, KT := false)
  1: wf_auto2.
Σ: Signature
Γ: Theory
AC: Application_context
Γ ⊢i ⊥ ---> ⊥
using (ExGen := ∅, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
AC: Application_context
Γ ⊢i ⊥ ---> AC.[□↦⊥]
using (ExGen := ∅, SVSubst := ∅, KT := false)
  {
Σ: Signature
Γ: Theory
AC: Application_context
Γ ⊢i ⊥ ---> ⊥
using (ExGen := ∅, SVSubst := ∅, KT := false)
    useBasicReasoning.
Σ: Signature
Γ: Theory
AC: Application_context
Γ ⊢i ⊥ ---> ⊥ using BasicReasoning
    apply A_impl_A.
Σ: Signature
Γ: Theory
AC: Application_context
well_formed ⊥
    reflexivity.
  }
Σ: Signature
Γ: Theory
AC: Application_context
Γ ⊢i ⊥ ---> AC.[□↦⊥]
using (ExGen := ∅, SVSubst := ∅, KT := false)
  {
Σ: Signature
Γ: Theory
AC: Application_context
Γ ⊢i ⊥ ---> AC.[□↦⊥]
using (ExGen := ∅, SVSubst := ∅, KT := false)
    useBasicReasoning.
Σ: Signature
Γ: Theory
AC: Application_context
Γ ⊢i ⊥ ---> AC.[□↦⊥] using BasicReasoning
    apply bot_elim.
Σ: Signature
Γ: Theory
AC: Application_context
well_formed AC.[□↦⊥]
    wf_auto2.
  }
Defined.

Lemma Prop_disj_left {Σ : Signature} (Γ : Theory) (ϕ₁ ϕ₂ ψ : Pattern) :
  well_formed ϕ₁ ->
  well_formed ϕ₂ ->
  well_formed ψ ->
  Γ ⊢i (ϕ₁ or ϕ₂) $ ψ ---> (ϕ₁ $ ψ) or (ϕ₂ $ ψ) using BasicReasoning.
Σ: Signature
Γ: Theory
ϕ₁, ϕ₂, ψ: Pattern
well_formed ϕ₁
→ well_formed ϕ₂
  → well_formed ψ
    → Γ ⊢i (ϕ₁ or ϕ₂) $ ψ ---> ϕ₁ $ ψ or ϕ₂ $ ψ
      using BasicReasoning
Proof.
Σ: Signature
Γ: Theory
ϕ₁, ϕ₂, ψ: Pattern
well_formed ϕ₁
→ well_formed ϕ₂
  → well_formed ψ
    → Γ ⊢i (ϕ₁ or ϕ₂) $ ψ ---> ϕ₁ $ ψ or ϕ₂ $ ψ
      using BasicReasoning
  intros wfϕ₁ wfϕ₂ wfψ.
Σ: Signature
Γ: Theory
ϕ₁, ϕ₂, ψ: Pattern
wfϕ₁: well_formed ϕ₁
wfϕ₂: well_formed ϕ₂
wfψ: well_formed ψ
Γ ⊢i (ϕ₁ or ϕ₂) $ ψ ---> ϕ₁ $ ψ or ϕ₂ $ ψ
using BasicReasoning
  unshelve (eexists).
Σ: Signature
Γ: Theory
ϕ₁, ϕ₂, ψ: Pattern
wfϕ₁: well_formed ϕ₁
wfϕ₂: well_formed ϕ₂
wfψ: well_formed ψ
ML_proof_system Γ
  ((ϕ₁ or ϕ₂) $ ψ ---> ϕ₁ $ ψ or ϕ₂ $ ψ)
Σ: Signature
Γ: Theory
ϕ₁, ϕ₂, ψ: Pattern
wfϕ₁: well_formed ϕ₁
wfϕ₂: well_formed ϕ₂
wfψ: well_formed ψ
ProofInfoMeaning Γ
  ((ϕ₁ or ϕ₂) $ ψ ---> ϕ₁ $ ψ or ϕ₂ $ ψ) 
  ?pf BasicReasoning
  {
Σ: Signature
Γ: Theory
ϕ₁, ϕ₂, ψ: Pattern
wfϕ₁: well_formed ϕ₁
wfϕ₂: well_formed ϕ₂
wfψ: well_formed ψ
ML_proof_system Γ
  ((ϕ₁ or ϕ₂) $ ψ ---> ϕ₁ $ ψ or ϕ₂ $ ψ)
    apply Prop_disj_left; assumption.
  }
Σ: Signature
Γ: Theory
ϕ₁, ϕ₂, ψ: Pattern
wfϕ₁: well_formed ϕ₁
wfϕ₂: well_formed ϕ₂
wfψ: well_formed ψ
ProofInfoMeaning Γ
  ((ϕ₁ or ϕ₂) $ ψ ---> ϕ₁ $ ψ or ϕ₂ $ ψ)
  (Prop_disj_left Γ ϕ₁ ϕ₂ ψ wfϕ₁ wfϕ₂ wfψ)
  BasicReasoning
  {
Σ: Signature
Γ: Theory
ϕ₁, ϕ₂, ψ: Pattern
wfϕ₁: well_formed ϕ₁
wfϕ₂: well_formed ϕ₂
wfψ: well_formed ψ
ProofInfoMeaning Γ
  ((ϕ₁ or ϕ₂) $ ψ ---> ϕ₁ $ ψ or ϕ₂ $ ψ)
  (Prop_disj_left Γ ϕ₁ ϕ₂ ψ wfϕ₁ wfϕ₂ wfψ)
  BasicReasoning
    abstract (solve_pim_simple).
  }
Defined.

Lemma Prop_disj_right {Σ : Signature} (Γ : Theory) (ϕ₁ ϕ₂ ψ : Pattern) :
  well_formed ϕ₁ ->
  well_formed ϕ₂ ->
  well_formed ψ ->
  Γ ⊢i ψ $ (ϕ₁ or ϕ₂)  ---> (ψ $ ϕ₁) or (ψ $ ϕ₂) using BasicReasoning.
Σ: Signature
Γ: Theory
ϕ₁, ϕ₂, ψ: Pattern
well_formed ϕ₁
→ well_formed ϕ₂
  → well_formed ψ
    → Γ ⊢i ψ $ (ϕ₁ or ϕ₂) ---> ψ $ ϕ₁ or ψ $ ϕ₂
      using BasicReasoning
Proof.
Σ: Signature
Γ: Theory
ϕ₁, ϕ₂, ψ: Pattern
well_formed ϕ₁
→ well_formed ϕ₂
  → well_formed ψ
    → Γ ⊢i ψ $ (ϕ₁ or ϕ₂) ---> ψ $ ϕ₁ or ψ $ ϕ₂
      using BasicReasoning
  intros wfϕ₁ wfϕ₂ wfψ.
Σ: Signature
Γ: Theory
ϕ₁, ϕ₂, ψ: Pattern
wfϕ₁: well_formed ϕ₁
wfϕ₂: well_formed ϕ₂
wfψ: well_formed ψ
Γ ⊢i ψ $ (ϕ₁ or ϕ₂) ---> ψ $ ϕ₁ or ψ $ ϕ₂
using BasicReasoning
  unshelve (eexists).
Σ: Signature
Γ: Theory
ϕ₁, ϕ₂, ψ: Pattern
wfϕ₁: well_formed ϕ₁
wfϕ₂: well_formed ϕ₂
wfψ: well_formed ψ
ML_proof_system Γ
  (ψ $ (ϕ₁ or ϕ₂) ---> ψ $ ϕ₁ or ψ $ ϕ₂)
Σ: Signature
Γ: Theory
ϕ₁, ϕ₂, ψ: Pattern
wfϕ₁: well_formed ϕ₁
wfϕ₂: well_formed ϕ₂
wfψ: well_formed ψ
ProofInfoMeaning Γ
  (ψ $ (ϕ₁ or ϕ₂) ---> ψ $ ϕ₁ or ψ $ ϕ₂) 
  ?pf BasicReasoning
  {
Σ: Signature
Γ: Theory
ϕ₁, ϕ₂, ψ: Pattern
wfϕ₁: well_formed ϕ₁
wfϕ₂: well_formed ϕ₂
wfψ: well_formed ψ
ML_proof_system Γ
  (ψ $ (ϕ₁ or ϕ₂) ---> ψ $ ϕ₁ or ψ $ ϕ₂)
    apply Prop_disj_right; assumption.
  }
Σ: Signature
Γ: Theory
ϕ₁, ϕ₂, ψ: Pattern
wfϕ₁: well_formed ϕ₁
wfϕ₂: well_formed ϕ₂
wfψ: well_formed ψ
ProofInfoMeaning Γ
  (ψ $ (ϕ₁ or ϕ₂) ---> ψ $ ϕ₁ or ψ $ ϕ₂)
  (Prop_disj_right Γ ϕ₁ ϕ₂ ψ wfϕ₁ wfϕ₂ wfψ)
  BasicReasoning
  {
Σ: Signature
Γ: Theory
ϕ₁, ϕ₂, ψ: Pattern
wfϕ₁: well_formed ϕ₁
wfϕ₂: well_formed ϕ₂
wfψ: well_formed ψ
ProofInfoMeaning Γ
  (ψ $ (ϕ₁ or ϕ₂) ---> ψ $ ϕ₁ or ψ $ ϕ₂)
  (Prop_disj_right Γ ϕ₁ ϕ₂ ψ wfϕ₁ wfϕ₂ wfψ)
  BasicReasoning
    abstract (solve_pim_simple).
  }
Defined.

Lemma prf_prop_or_iff {Σ : Signature} Γ AC p q:
  well_formed p ->
  well_formed q ->
  Γ ⊢i ((subst_ctx AC (p or q)) <---> ((subst_ctx AC p) or (subst_ctx AC q)))
  using (
  (ExGen := ∅, SVSubst := ∅, KT := false)).
Σ: Signature
Γ: Theory
AC: Application_context
p, q: Pattern
well_formed p
→ well_formed q
  → Γ ⊢i AC.[□↦p or q] <---> AC.[□↦p] or AC.[□↦q]
    using (ExGen := ∅, SVSubst := ∅, KT := false)
Proof.
Σ: Signature
Γ: Theory
AC: Application_context
p, q: Pattern
well_formed p
→ well_formed q
  → Γ ⊢i AC.[□↦p or q] <---> AC.[□↦p] or AC.[□↦q]
    using (ExGen := ∅, SVSubst := ∅, KT := false)
  intros wfp wfq.
Σ: Signature
Γ: Theory
AC: Application_context
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
Γ ⊢i AC.[□↦p or q] <---> AC.[□↦p] or AC.[□↦q]
using (ExGen := ∅, SVSubst := ∅, KT := false)
  induction AC; simpl.
Σ: Signature
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
Γ ⊢i p or q <---> p or q
using (ExGen := ∅, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
IHAC: Γ ⊢i AC.[□↦p or q] <---> AC.[□↦p] or AC.[□↦q]
using (ExGen := ∅, SVSubst := ∅, KT := false)
Γ
⊢i AC.[□↦p or q] $ p0 <--->
   AC.[□↦p] $ p0 or AC.[□↦q] $ p0
using (ExGen := ∅, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
IHAC: Γ ⊢i AC.[□↦p or q] <---> AC.[□↦p] or AC.[□↦q]
using (ExGen := ∅, SVSubst := ∅, KT := false)
Γ
⊢i p0 $ AC.[□↦p or q] <--->
   p0 $ AC.[□↦p] or p0 $ AC.[□↦q]
using (ExGen := ∅, SVSubst := ∅, KT := false)
  -
Σ: Signature
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
Γ ⊢i p or q <---> p or q
using (ExGen := ∅, SVSubst := ∅, KT := false) useBasicReasoning.
Σ: Signature
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
Γ ⊢i p or q <---> p or q using BasicReasoning apply pf_iff_equiv_refl; wf_auto2.
  -
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
IHAC: Γ ⊢i AC.[□↦p or q] <---> AC.[□↦p] or AC.[□↦q]
using (ExGen := ∅, SVSubst := ∅, KT := false)
Γ
⊢i AC.[□↦p or q] $ p0 <--->
   AC.[□↦p] $ p0 or AC.[□↦q] $ p0
using (ExGen := ∅, SVSubst := ∅, KT := false) apply pf_iff_iff in IHAC; try_wfauto2.
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
IHAC: ((Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q]
  using (ExGen := ∅, SVSubst := ∅, KT := false)) *
 (Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q]
  using (ExGen := ∅, SVSubst := ∅, KT := false)))%type
Γ
⊢i AC.[□↦p or q] $ p0 <--->
   AC.[□↦p] $ p0 or AC.[□↦q] $ p0
using (ExGen := ∅, SVSubst := ∅, KT := false)
    destruct IHAC as [IH1 IH2].
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q]
using (ExGen := ∅, SVSubst := ∅, KT := false)
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q]
using (ExGen := ∅, SVSubst := ∅, KT := false)
Γ
⊢i AC.[□↦p or q] $ p0 <--->
   AC.[□↦p] $ p0 or AC.[□↦q] $ p0
using (ExGen := ∅, SVSubst := ∅, KT := false)
    remember_constraint as i.
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
i: ProofInfo
Heqi: i = (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q]
using i
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q]
using i
Γ
⊢i AC.[□↦p or q] $ p0 <--->
   AC.[□↦p] $ p0 or AC.[□↦q] $ p0 using i
    apply pf_iff_split; try_wfauto2.
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
i: ProofInfo
Heqi: i = (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q]
using i
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q]
using i
Γ
⊢i AC.[□↦p or q] $ p0 --->
   AC.[□↦p] $ p0 or AC.[□↦q] $ p0 using i
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
i: ProofInfo
Heqi: i = (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q]
using i
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q]
using i
Γ
⊢i AC.[□↦p] $ p0 or AC.[□↦q] $ p0 --->
   AC.[□↦p or q] $ p0 using i
    +
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
i: ProofInfo
Heqi: i = (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q]
using i
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q]
using i
Γ
⊢i AC.[□↦p or q] $ p0 --->
   AC.[□↦p] $ p0 or AC.[□↦q] $ p0 using i pose proof (H := IH1).
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
i: ProofInfo
Heqi: i = (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q]
using i
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q]
using i
H: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q]
using i
Γ
⊢i AC.[□↦p or q] $ p0 --->
   AC.[□↦p] $ p0 or AC.[□↦q] $ p0 using i
      apply useGenericReasoning with (i := i) in H.
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
i: ProofInfo
Heqi: i = (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q]
using i
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q]
using i
H: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q]
using i
Γ
⊢i AC.[□↦p or q] $ p0 --->
   AC.[□↦p] $ p0 or AC.[□↦q] $ p0 using i
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
i: ProofInfo
Heqi: i = (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q]
using i
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q]
using i
H: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q]
using i
ProofInfoLe i i
      2: {
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
i: ProofInfo
Heqi: i = (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q]
using i
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q]
using i
H: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q]
using i
ProofInfoLe i i try_solve_pile. }
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
i: ProofInfo
Heqi: i = (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q]
using i
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q]
using i
H: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q]
using i
Γ
⊢i AC.[□↦p or q] $ p0 --->
   AC.[□↦p] $ p0 or AC.[□↦q] $ p0 using i
      rewrite Heqi in H.
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
i: ProofInfo
Heqi: i = (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q]
using i
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q]
using i
H: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q]
using (ExGen := ∅, SVSubst := ∅, KT := false)
Γ
⊢i AC.[□↦p or q] $ p0 --->
   AC.[□↦p] $ p0 or AC.[□↦q] $ p0 using i
      apply Framing_left with (ψ := p0)in H; auto.
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
i: ProofInfo
Heqi: i = (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q]
using i
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q]
using i
H: Γ
⊢i AC.[□↦p or q] $ p0 --->
   (AC.[□↦p] or AC.[□↦q]) $ p0
using (ExGen := ∅, SVSubst := ∅, KT := false)
Γ
⊢i AC.[□↦p or q] $ p0 --->
   AC.[□↦p] $ p0 or AC.[□↦q] $ p0 using i
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
i: ProofInfo
Heqi: i = (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q]
using i
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q]
using i
H: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q]
using (ExGen := ∅, SVSubst := ∅, KT := false)
ProofInfoLe (ExGen := ∅, SVSubst := ∅, KT := false)
  (ExGen := ∅, SVSubst := ∅, KT := false)
      2: {
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
i: ProofInfo
Heqi: i = (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q]
using i
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q]
using i
H: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q]
using (ExGen := ∅, SVSubst := ∅, KT := false)
ProofInfoLe (ExGen := ∅, SVSubst := ∅, KT := false)
  (ExGen := ∅, SVSubst := ∅, KT := false) apply pile_refl. }
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
i: ProofInfo
Heqi: i = (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q]
using i
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q]
using i
H: Γ
⊢i AC.[□↦p or q] $ p0 --->
   (AC.[□↦p] or AC.[□↦q]) $ p0
using (ExGen := ∅, SVSubst := ∅, KT := false)
Γ
⊢i AC.[□↦p or q] $ p0 --->
   AC.[□↦p] $ p0 or AC.[□↦q] $ p0 using i
      eapply syllogism_meta.
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
i: ProofInfo
Heqi: i = (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q]
using i
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q]
using i
H: Γ
⊢i AC.[□↦p or q] $ p0 --->
   (AC.[□↦p] or AC.[□↦q]) $ p0
using (ExGen := ∅, SVSubst := ∅, KT := false)
well_formed (AC.[□↦p or q] $ p0)
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
i: ProofInfo
Heqi: i = (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q]
using i
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q]
using i
H: Γ
⊢i AC.[□↦p or q] $ p0 --->
   (AC.[□↦p] or AC.[□↦q]) $ p0
using (ExGen := ∅, SVSubst := ∅, KT := false)
well_formed ?B
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
i: ProofInfo
Heqi: i = (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q]
using i
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q]
using i
H: Γ
⊢i AC.[□↦p or q] $ p0 --->
   (AC.[□↦p] or AC.[□↦q]) $ p0
using (ExGen := ∅, SVSubst := ∅, KT := false)
well_formed (AC.[□↦p] $ p0 or AC.[□↦q] $ p0)
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
i: ProofInfo
Heqi: i = (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q]
using i
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q]
using i
H: Γ
⊢i AC.[□↦p or q] $ p0 --->
   (AC.[□↦p] or AC.[□↦q]) $ p0
using (ExGen := ∅, SVSubst := ∅, KT := false)
Γ ⊢i AC.[□↦p or q] $ p0 ---> ?B using i
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
i: ProofInfo
Heqi: i = (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q]
using i
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q]
using i
H: Γ
⊢i AC.[□↦p or q] $ p0 --->
   (AC.[□↦p] or AC.[□↦q]) $ p0
using (ExGen := ∅, SVSubst := ∅, KT := false)
Γ ⊢i ?B ---> AC.[□↦p] $ p0 or AC.[□↦q] $ p0 using i 4: subst i; apply H.
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
i: ProofInfo
Heqi: i = (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q]
using i
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q]
using i
H: Γ
⊢i AC.[□↦p or q] $ p0 --->
   (AC.[□↦p] or AC.[□↦q]) $ p0
using (ExGen := ∅, SVSubst := ∅, KT := false)
well_formed (AC.[□↦p or q] $ p0)
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
i: ProofInfo
Heqi: i = (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q]
using i
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q]
using i
H: Γ
⊢i AC.[□↦p or q] $ p0 --->
   (AC.[□↦p] or AC.[□↦q]) $ p0
using (ExGen := ∅, SVSubst := ∅, KT := false)
well_formed ((AC.[□↦p] or AC.[□↦q]) $ p0)
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
i: ProofInfo
Heqi: i = (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q]
using i
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q]
using i
H: Γ
⊢i AC.[□↦p or q] $ p0 --->
   (AC.[□↦p] or AC.[□↦q]) $ p0
using (ExGen := ∅, SVSubst := ∅, KT := false)
well_formed (AC.[□↦p] $ p0 or AC.[□↦q] $ p0)
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
i: ProofInfo
Heqi: i = (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q]
using i
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q]
using i
H: Γ
⊢i AC.[□↦p or q] $ p0 --->
   (AC.[□↦p] or AC.[□↦q]) $ p0
using (ExGen := ∅, SVSubst := ∅, KT := false)
Γ
⊢i (AC.[□↦p] or AC.[□↦q]) $ p0 --->
   AC.[□↦p] $ p0 or AC.[□↦q] $ p0 using i
      all: try_wfauto2.
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
i: ProofInfo
Heqi: i = (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q]
using i
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q]
using i
H: Γ
⊢i AC.[□↦p or q] $ p0 --->
   (AC.[□↦p] or AC.[□↦q]) $ p0
using (ExGen := ∅, SVSubst := ∅, KT := false)
Γ
⊢i (AC.[□↦p] or AC.[□↦q]) $ p0 --->
   AC.[□↦p] $ p0 or AC.[□↦q] $ p0 using i
      remember (subst_ctx AC p) as p'.
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
i: ProofInfo
Heqi: i = (ExGen := ∅, SVSubst := ∅, KT := false)
p': Pattern
Heqp': p' = AC.[□↦p]
IH1: Γ ⊢i AC.[□↦p or q] ---> p' or AC.[□↦q] using i
IH2: Γ ⊢i p' or AC.[□↦q] ---> AC.[□↦p or q] using i
H: Γ ⊢i AC.[□↦p or q] $ p0 ---> (p' or AC.[□↦q]) $ p0
using (ExGen := ∅, SVSubst := ∅, KT := false)
Γ
⊢i (p' or AC.[□↦q]) $ p0 ---> p' $ p0 or AC.[□↦q] $ p0
using i
      remember (subst_ctx AC q) as q'.
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
i: ProofInfo
Heqi: i = (ExGen := ∅, SVSubst := ∅, KT := false)
p': Pattern
Heqp': p' = AC.[□↦p]
q': Pattern
Heqq': q' = AC.[□↦q]
IH1: Γ ⊢i AC.[□↦p or q] ---> p' or q' using i
IH2: Γ ⊢i p' or q' ---> AC.[□↦p or q] using i
H: Γ ⊢i AC.[□↦p or q] $ p0 ---> (p' or q') $ p0
using (ExGen := ∅, SVSubst := ∅, KT := false)
Γ ⊢i (p' or q') $ p0 ---> p' $ p0 or q' $ p0 using i
      subst i.
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
p': Pattern
Heqp': p' = AC.[□↦p]
q': Pattern
Heqq': q' = AC.[□↦q]
IH2: Γ ⊢i p' or q' ---> AC.[□↦p or q]
using (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> p' or q'
using (ExGen := ∅, SVSubst := ∅, KT := false)
H: Γ ⊢i AC.[□↦p or q] $ p0 ---> (p' or q') $ p0
using (ExGen := ∅, SVSubst := ∅, KT := false)
Γ ⊢i (p' or q') $ p0 ---> p' $ p0 or q' $ p0
using (ExGen := ∅, SVSubst := ∅, KT := false)
      eapply useGenericReasoning.
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
p': Pattern
Heqp': p' = AC.[□↦p]
q': Pattern
Heqq': q' = AC.[□↦q]
IH2: Γ ⊢i p' or q' ---> AC.[□↦p or q]
using (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> p' or q'
using (ExGen := ∅, SVSubst := ∅, KT := false)
H: Γ ⊢i AC.[□↦p or q] $ p0 ---> (p' or q') $ p0
using (ExGen := ∅, SVSubst := ∅, KT := false)
ProofInfoLe ?i'
  (ExGen := ∅, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
p': Pattern
Heqp': p' = AC.[□↦p]
q': Pattern
Heqq': q' = AC.[□↦q]
IH2: Γ ⊢i p' or q' ---> AC.[□↦p or q]
using (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> p' or q'
using (ExGen := ∅, SVSubst := ∅, KT := false)
H: Γ ⊢i AC.[□↦p or q] $ p0 ---> (p' or q') $ p0
using (ExGen := ∅, SVSubst := ∅, KT := false)
Γ ⊢i (p' or q') $ p0 ---> p' $ p0 or q' $ p0 using ?i'
      2: eapply Prop_disj_left.
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
p': Pattern
Heqp': p' = AC.[□↦p]
q': Pattern
Heqq': q' = AC.[□↦q]
IH2: Γ ⊢i p' or q' ---> AC.[□↦p or q]
using (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> p' or q'
using (ExGen := ∅, SVSubst := ∅, KT := false)
H: Γ ⊢i AC.[□↦p or q] $ p0 ---> (p' or q') $ p0
using (ExGen := ∅, SVSubst := ∅, KT := false)
ProofInfoLe BasicReasoning
  (ExGen := ∅, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
p': Pattern
Heqp': p' = AC.[□↦p]
q': Pattern
Heqq': q' = AC.[□↦q]
IH2: Γ ⊢i p' or q' ---> AC.[□↦p or q]
using (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> p' or q'
using (ExGen := ∅, SVSubst := ∅, KT := false)
H: Γ ⊢i AC.[□↦p or q] $ p0 ---> (p' or q') $ p0
using (ExGen := ∅, SVSubst := ∅, KT := false)
well_formed p'
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
p': Pattern
Heqp': p' = AC.[□↦p]
q': Pattern
Heqq': q' = AC.[□↦q]
IH2: Γ ⊢i p' or q' ---> AC.[□↦p or q]
using (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> p' or q'
using (ExGen := ∅, SVSubst := ∅, KT := false)
H: Γ ⊢i AC.[□↦p or q] $ p0 ---> (p' or q') $ p0
using (ExGen := ∅, SVSubst := ∅, KT := false)
well_formed q'
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
p': Pattern
Heqp': p' = AC.[□↦p]
q': Pattern
Heqq': q' = AC.[□↦q]
IH2: Γ ⊢i p' or q' ---> AC.[□↦p or q]
using (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> p' or q'
using (ExGen := ∅, SVSubst := ∅, KT := false)
H: Γ ⊢i AC.[□↦p or q] $ p0 ---> (p' or q') $ p0
using (ExGen := ∅, SVSubst := ∅, KT := false)
well_formed p0 all: subst; try_wfauto2.
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q]
using (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q]
using (ExGen := ∅, SVSubst := ∅, KT := false)
H: Γ
⊢i AC.[□↦p or q] $ p0 --->
   (AC.[□↦p] or AC.[□↦q]) $ p0
using (ExGen := ∅, SVSubst := ∅, KT := false)
ProofInfoLe BasicReasoning
  (ExGen := ∅, SVSubst := ∅, KT := false)
      {
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q]
using (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q]
using (ExGen := ∅, SVSubst := ∅, KT := false)
H: Γ
⊢i AC.[□↦p or q] $ p0 --->
   (AC.[□↦p] or AC.[□↦q]) $ p0
using (ExGen := ∅, SVSubst := ∅, KT := false)
ProofInfoLe BasicReasoning
  (ExGen := ∅, SVSubst := ∅, KT := false) try_solve_pile. }
    +
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
i: ProofInfo
Heqi: i = (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q]
using i
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q]
using i
Γ
⊢i AC.[□↦p] $ p0 or AC.[□↦q] $ p0 --->
   AC.[□↦p or q] $ p0 using i eapply prf_disj_elim_meta_meta; try_wfauto2.
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
i: ProofInfo
Heqi: i = (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q]
using i
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q]
using i
Γ ⊢i AC.[□↦p] $ p0 ---> AC.[□↦p or q] $ p0 using i
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
i: ProofInfo
Heqi: i = (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q]
using i
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q]
using i
Γ ⊢i AC.[□↦q] $ p0 ---> AC.[□↦p or q] $ p0 using i
      *
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
i: ProofInfo
Heqi: i = (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q]
using i
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q]
using i
Γ ⊢i AC.[□↦p] $ p0 ---> AC.[□↦p or q] $ p0 using i subst i.
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q]
using (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q]
using (ExGen := ∅, SVSubst := ∅, KT := false)
Γ ⊢i AC.[□↦p] $ p0 ---> AC.[□↦p or q] $ p0
using (ExGen := ∅, SVSubst := ∅, KT := false) 
        apply Framing_left with (ψ := p0); auto.
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q]
using (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q]
using (ExGen := ∅, SVSubst := ∅, KT := false)
ProofInfoLe (ExGen := ∅, SVSubst := ∅, KT := false)
  (ExGen := ∅, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q]
using (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q]
using (ExGen := ∅, SVSubst := ∅, KT := false)
Γ ⊢i AC.[□↦p] ---> AC.[□↦p or q]
using (ExGen := ∅, SVSubst := ∅, KT := false)
        {
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q]
using (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q]
using (ExGen := ∅, SVSubst := ∅, KT := false)
ProofInfoLe (ExGen := ∅, SVSubst := ∅, KT := false)
  (ExGen := ∅, SVSubst := ∅, KT := false) try_solve_pile. }
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q]
using (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q]
using (ExGen := ∅, SVSubst := ∅, KT := false)
Γ ⊢i AC.[□↦p] ---> AC.[□↦p or q]
using (ExGen := ∅, SVSubst := ∅, KT := false)
        eapply prf_weaken_conclusion_meta_meta.
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q]
using (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q]
using (ExGen := ∅, SVSubst := ∅, KT := false)
well_formed AC.[□↦p]
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q]
using (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q]
using (ExGen := ∅, SVSubst := ∅, KT := false)
well_formed ?B
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q]
using (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q]
using (ExGen := ∅, SVSubst := ∅, KT := false)
well_formed AC.[□↦p or q]
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q]
using (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q]
using (ExGen := ∅, SVSubst := ∅, KT := false)
Γ ⊢i ?B ---> AC.[□↦p or q]
using (ExGen := ∅, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q]
using (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q]
using (ExGen := ∅, SVSubst := ∅, KT := false)
Γ ⊢i AC.[□↦p] ---> ?B
using (ExGen := ∅, SVSubst := ∅, KT := false)
        4: {
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q]
using (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q]
using (ExGen := ∅, SVSubst := ∅, KT := false)
Γ ⊢i ?B ---> AC.[□↦p or q]
using (ExGen := ∅, SVSubst := ∅, KT := false) gapply IH2.
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q]
using (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q]
using (ExGen := ∅, SVSubst := ∅, KT := false)
ProofInfoLe (ExGen := ∅, SVSubst := ∅, KT := false)
  (ExGen := ∅, SVSubst := ∅, KT := false) try_solve_pile. }
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q]
using (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q]
using (ExGen := ∅, SVSubst := ∅, KT := false)
well_formed AC.[□↦p]
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q]
using (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q]
using (ExGen := ∅, SVSubst := ∅, KT := false)
well_formed (AC.[□↦p] or AC.[□↦q])
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q]
using (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q]
using (ExGen := ∅, SVSubst := ∅, KT := false)
well_formed AC.[□↦p or q]
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q]
using (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q]
using (ExGen := ∅, SVSubst := ∅, KT := false)
Γ ⊢i AC.[□↦p] ---> AC.[□↦p] or AC.[□↦q]
using (ExGen := ∅, SVSubst := ∅, KT := false)
        1-3: wf_auto2.
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q]
using (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q]
using (ExGen := ∅, SVSubst := ∅, KT := false)
Γ ⊢i AC.[□↦p] ---> AC.[□↦p] or AC.[□↦q]
using (ExGen := ∅, SVSubst := ∅, KT := false)
        useBasicReasoning.
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q]
using (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q]
using (ExGen := ∅, SVSubst := ∅, KT := false)
Γ ⊢i AC.[□↦p] ---> AC.[□↦p] or AC.[□↦q]
using BasicReasoning
        apply disj_left_intro; wf_auto2.
      *
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
i: ProofInfo
Heqi: i = (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q]
using i
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q]
using i
Γ ⊢i AC.[□↦q] $ p0 ---> AC.[□↦p or q] $ p0 using i subst i.
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q]
using (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q]
using (ExGen := ∅, SVSubst := ∅, KT := false)
Γ ⊢i AC.[□↦q] $ p0 ---> AC.[□↦p or q] $ p0
using (ExGen := ∅, SVSubst := ∅, KT := false)
        apply Framing_left with (ψ := p0); auto.
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q]
using (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q]
using (ExGen := ∅, SVSubst := ∅, KT := false)
ProofInfoLe (ExGen := ∅, SVSubst := ∅, KT := false)
  (ExGen := ∅, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q]
using (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q]
using (ExGen := ∅, SVSubst := ∅, KT := false)
Γ ⊢i AC.[□↦q] ---> AC.[□↦p or q]
using (ExGen := ∅, SVSubst := ∅, KT := false)
        {
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q]
using (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q]
using (ExGen := ∅, SVSubst := ∅, KT := false)
ProofInfoLe (ExGen := ∅, SVSubst := ∅, KT := false)
  (ExGen := ∅, SVSubst := ∅, KT := false) try_solve_pile. }
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q]
using (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q]
using (ExGen := ∅, SVSubst := ∅, KT := false)
Γ ⊢i AC.[□↦q] ---> AC.[□↦p or q]
using (ExGen := ∅, SVSubst := ∅, KT := false)
        eapply prf_weaken_conclusion_meta_meta.
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q]
using (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q]
using (ExGen := ∅, SVSubst := ∅, KT := false)
well_formed AC.[□↦q]
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q]
using (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q]
using (ExGen := ∅, SVSubst := ∅, KT := false)
well_formed ?B
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q]
using (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q]
using (ExGen := ∅, SVSubst := ∅, KT := false)
well_formed AC.[□↦p or q]
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q]
using (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q]
using (ExGen := ∅, SVSubst := ∅, KT := false)
Γ ⊢i ?B ---> AC.[□↦p or q]
using (ExGen := ∅, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q]
using (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q]
using (ExGen := ∅, SVSubst := ∅, KT := false)
Γ ⊢i AC.[□↦q] ---> ?B
using (ExGen := ∅, SVSubst := ∅, KT := false) 4: gapply IH2; try_solve_pile.
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q]
using (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q]
using (ExGen := ∅, SVSubst := ∅, KT := false)
well_formed AC.[□↦q]
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q]
using (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q]
using (ExGen := ∅, SVSubst := ∅, KT := false)
well_formed (AC.[□↦p] or AC.[□↦q])
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q]
using (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q]
using (ExGen := ∅, SVSubst := ∅, KT := false)
well_formed AC.[□↦p or q]
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q]
using (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q]
using (ExGen := ∅, SVSubst := ∅, KT := false)
Γ ⊢i AC.[□↦q] ---> AC.[□↦p] or AC.[□↦q]
using (ExGen := ∅, SVSubst := ∅, KT := false) all: try_wfauto2.
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q]
using (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q]
using (ExGen := ∅, SVSubst := ∅, KT := false)
Γ ⊢i AC.[□↦q] ---> AC.[□↦p] or AC.[□↦q]
using (ExGen := ∅, SVSubst := ∅, KT := false)
        useBasicReasoning.
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q]
using (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q]
using (ExGen := ∅, SVSubst := ∅, KT := false)
Γ ⊢i AC.[□↦q] ---> AC.[□↦p] or AC.[□↦q]
using BasicReasoning
        apply disj_right_intro; wf_auto2.
  -
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
IHAC: Γ ⊢i AC.[□↦p or q] <---> AC.[□↦p] or AC.[□↦q]
using (ExGen := ∅, SVSubst := ∅, KT := false)
Γ
⊢i p0 $ AC.[□↦p or q] <--->
   p0 $ AC.[□↦p] or p0 $ AC.[□↦q]
using (ExGen := ∅, SVSubst := ∅, KT := false) apply pf_iff_iff in IHAC; try_wfauto2.
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
IHAC: ((Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q]
  using (ExGen := ∅, SVSubst := ∅, KT := false)) *
 (Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q]
  using (ExGen := ∅, SVSubst := ∅, KT := false)))%type
Γ
⊢i p0 $ AC.[□↦p or q] <--->
   p0 $ AC.[□↦p] or p0 $ AC.[□↦q]
using (ExGen := ∅, SVSubst := ∅, KT := false)
    destruct IHAC as [IH1 IH2].
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q]
using (ExGen := ∅, SVSubst := ∅, KT := false)
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q]
using (ExGen := ∅, SVSubst := ∅, KT := false)
Γ
⊢i p0 $ AC.[□↦p or q] <--->
   p0 $ AC.[□↦p] or p0 $ AC.[□↦q]
using (ExGen := ∅, SVSubst := ∅, KT := false)
    remember_constraint as i.
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
i: ProofInfo
Heqi: i = (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q]
using i
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q]
using i
Γ
⊢i p0 $ AC.[□↦p or q] <--->
   p0 $ AC.[□↦p] or p0 $ AC.[□↦q] using i
    apply pf_iff_split; try_wfauto2.
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
i: ProofInfo
Heqi: i = (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q]
using i
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q]
using i
Γ
⊢i p0 $ AC.[□↦p or q] --->
   p0 $ AC.[□↦p] or p0 $ AC.[□↦q] using i
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
i: ProofInfo
Heqi: i = (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q]
using i
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q]
using i
Γ
⊢i p0 $ AC.[□↦p] or p0 $ AC.[□↦q] --->
   p0 $ AC.[□↦p or q] using i
    +
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
i: ProofInfo
Heqi: i = (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q]
using i
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q]
using i
Γ
⊢i p0 $ AC.[□↦p or q] --->
   p0 $ AC.[□↦p] or p0 $ AC.[□↦q] using i pose proof (H := IH1).
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
i: ProofInfo
Heqi: i = (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q]
using i
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q]
using i
H: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q]
using i
Γ
⊢i p0 $ AC.[□↦p or q] --->
   p0 $ AC.[□↦p] or p0 $ AC.[□↦q] using i
      apply useGenericReasoning with (i := i) in H.
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
i: ProofInfo
Heqi: i = (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q]
using i
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q]
using i
H: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q]
using i
Γ
⊢i p0 $ AC.[□↦p or q] --->
   p0 $ AC.[□↦p] or p0 $ AC.[□↦q] using i
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
i: ProofInfo
Heqi: i = (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q]
using i
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q]
using i
H: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q]
using i
ProofInfoLe i i
      2: {
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
i: ProofInfo
Heqi: i = (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q]
using i
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q]
using i
H: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q]
using i
ProofInfoLe i i subst i.
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
H: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q]
using (ExGen := ∅, SVSubst := ∅, KT := false)
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q]
using (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q]
using (ExGen := ∅, SVSubst := ∅, KT := false)
ProofInfoLe (ExGen := ∅, SVSubst := ∅, KT := false)
  (ExGen := ∅, SVSubst := ∅, KT := false) try_solve_pile. }
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
i: ProofInfo
Heqi: i = (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q]
using i
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q]
using i
H: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q]
using i
Γ
⊢i p0 $ AC.[□↦p or q] --->
   p0 $ AC.[□↦p] or p0 $ AC.[□↦q] using i
      eapply Framing_right with (ψ := p0)in H; auto.
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
i: ProofInfo
Heqi: i = (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q]
using i
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q]
using i
H: Γ
⊢i p0 $ AC.[□↦p or q] --->
   p0 $ (AC.[□↦p] or AC.[□↦q]) using i
Γ
⊢i p0 $ AC.[□↦p or q] --->
   p0 $ AC.[□↦p] or p0 $ AC.[□↦q] using i
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
i: ProofInfo
Heqi: i = (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q]
using i
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q]
using i
H: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q]
using i
ProofInfoLe (ExGen := ∅, SVSubst := ∅, KT := false) i
      eapply syllogism_meta.
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
i: ProofInfo
Heqi: i = (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q]
using i
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q]
using i
H: Γ
⊢i p0 $ AC.[□↦p or q] --->
   p0 $ (AC.[□↦p] or AC.[□↦q]) using i
well_formed (p0 $ AC.[□↦p or q])
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
i: ProofInfo
Heqi: i = (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q]
using i
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q]
using i
H: Γ
⊢i p0 $ AC.[□↦p or q] --->
   p0 $ (AC.[□↦p] or AC.[□↦q]) using i
well_formed ?B
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
i: ProofInfo
Heqi: i = (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q]
using i
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q]
using i
H: Γ
⊢i p0 $ AC.[□↦p or q] --->
   p0 $ (AC.[□↦p] or AC.[□↦q]) using i
well_formed (p0 $ AC.[□↦p] or p0 $ AC.[□↦q])
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
i: ProofInfo
Heqi: i = (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q]
using i
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q]
using i
H: Γ
⊢i p0 $ AC.[□↦p or q] --->
   p0 $ (AC.[□↦p] or AC.[□↦q]) using i
Γ ⊢i p0 $ AC.[□↦p or q] ---> ?B using i
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
i: ProofInfo
Heqi: i = (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q]
using i
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q]
using i
H: Γ
⊢i p0 $ AC.[□↦p or q] --->
   p0 $ (AC.[□↦p] or AC.[□↦q]) using i
Γ ⊢i ?B ---> p0 $ AC.[□↦p] or p0 $ AC.[□↦q] using i
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
i: ProofInfo
Heqi: i = (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q]
using i
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q]
using i
H: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q]
using i
ProofInfoLe (ExGen := ∅, SVSubst := ∅, KT := false) i 4: apply H.
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
i: ProofInfo
Heqi: i = (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q]
using i
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q]
using i
H: Γ
⊢i p0 $ AC.[□↦p or q] --->
   p0 $ (AC.[□↦p] or AC.[□↦q]) using i
well_formed (p0 $ AC.[□↦p or q])
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
i: ProofInfo
Heqi: i = (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q]
using i
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q]
using i
H: Γ
⊢i p0 $ AC.[□↦p or q] --->
   p0 $ (AC.[□↦p] or AC.[□↦q]) using i
well_formed (p0 $ (AC.[□↦p] or AC.[□↦q]))
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
i: ProofInfo
Heqi: i = (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q]
using i
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q]
using i
H: Γ
⊢i p0 $ AC.[□↦p or q] --->
   p0 $ (AC.[□↦p] or AC.[□↦q]) using i
well_formed (p0 $ AC.[□↦p] or p0 $ AC.[□↦q])
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
i: ProofInfo
Heqi: i = (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q]
using i
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q]
using i
H: Γ
⊢i p0 $ AC.[□↦p or q] --->
   p0 $ (AC.[□↦p] or AC.[□↦q]) using i
Γ
⊢i p0 $ (AC.[□↦p] or AC.[□↦q]) --->
   p0 $ AC.[□↦p] or p0 $ AC.[□↦q] using i
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
i: ProofInfo
Heqi: i = (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q]
using i
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q]
using i
H: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q]
using i
ProofInfoLe (ExGen := ∅, SVSubst := ∅, KT := false) i
      all: try_wfauto2.
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
i: ProofInfo
Heqi: i = (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q]
using i
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q]
using i
H: Γ
⊢i p0 $ AC.[□↦p or q] --->
   p0 $ (AC.[□↦p] or AC.[□↦q]) using i
Γ
⊢i p0 $ (AC.[□↦p] or AC.[□↦q]) --->
   p0 $ AC.[□↦p] or p0 $ AC.[□↦q] using i
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
i: ProofInfo
Heqi: i = (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q]
using i
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q]
using i
H: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q]
using i
ProofInfoLe (ExGen := ∅, SVSubst := ∅, KT := false) i
      2: {
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
i: ProofInfo
Heqi: i = (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q]
using i
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q]
using i
H: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q]
using i
ProofInfoLe (ExGen := ∅, SVSubst := ∅, KT := false) i subst i.
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
H: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q]
using (ExGen := ∅, SVSubst := ∅, KT := false)
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q]
using (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q]
using (ExGen := ∅, SVSubst := ∅, KT := false)
ProofInfoLe (ExGen := ∅, SVSubst := ∅, KT := false)
  (ExGen := ∅, SVSubst := ∅, KT := false) try_solve_pile. }
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
i: ProofInfo
Heqi: i = (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q]
using i
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q]
using i
H: Γ
⊢i p0 $ AC.[□↦p or q] --->
   p0 $ (AC.[□↦p] or AC.[□↦q]) using i
Γ
⊢i p0 $ (AC.[□↦p] or AC.[□↦q]) --->
   p0 $ AC.[□↦p] or p0 $ AC.[□↦q] using i
      remember (subst_ctx AC p) as p'.
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
i: ProofInfo
Heqi: i = (ExGen := ∅, SVSubst := ∅, KT := false)
p': Pattern
Heqp': p' = AC.[□↦p]
IH1: Γ ⊢i AC.[□↦p or q] ---> p' or AC.[□↦q] using i
IH2: Γ ⊢i p' or AC.[□↦q] ---> AC.[□↦p or q] using i
H: Γ ⊢i p0 $ AC.[□↦p or q] ---> p0 $ (p' or AC.[□↦q])
using i
Γ
⊢i p0 $ (p' or AC.[□↦q]) ---> p0 $ p' or p0 $ AC.[□↦q]
using i
      remember (subst_ctx AC q) as q'.
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
i: ProofInfo
Heqi: i = (ExGen := ∅, SVSubst := ∅, KT := false)
p': Pattern
Heqp': p' = AC.[□↦p]
q': Pattern
Heqq': q' = AC.[□↦q]
IH1: Γ ⊢i AC.[□↦p or q] ---> p' or q' using i
IH2: Γ ⊢i p' or q' ---> AC.[□↦p or q] using i
H: Γ ⊢i p0 $ AC.[□↦p or q] ---> p0 $ (p' or q')
using i
Γ ⊢i p0 $ (p' or q') ---> p0 $ p' or p0 $ q' using i
      subst i; apply useBasicReasoning.
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
p': Pattern
Heqp': p' = AC.[□↦p]
q': Pattern
Heqq': q' = AC.[□↦q]
H: Γ ⊢i p0 $ AC.[□↦p or q] ---> p0 $ (p' or q')
using (ExGen := ∅, SVSubst := ∅, KT := false)
IH2: Γ ⊢i p' or q' ---> AC.[□↦p or q]
using (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> p' or q'
using (ExGen := ∅, SVSubst := ∅, KT := false)
Γ ⊢i p0 $ (p' or q') ---> p0 $ p' or p0 $ q'
using BasicReasoning
      apply Prop_disj_right.
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
p': Pattern
Heqp': p' = AC.[□↦p]
q': Pattern
Heqq': q' = AC.[□↦q]
H: Γ ⊢i p0 $ AC.[□↦p or q] ---> p0 $ (p' or q')
using (ExGen := ∅, SVSubst := ∅, KT := false)
IH2: Γ ⊢i p' or q' ---> AC.[□↦p or q]
using (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> p' or q'
using (ExGen := ∅, SVSubst := ∅, KT := false)
well_formed p'
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
p': Pattern
Heqp': p' = AC.[□↦p]
q': Pattern
Heqq': q' = AC.[□↦q]
H: Γ ⊢i p0 $ AC.[□↦p or q] ---> p0 $ (p' or q')
using (ExGen := ∅, SVSubst := ∅, KT := false)
IH2: Γ ⊢i p' or q' ---> AC.[□↦p or q]
using (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> p' or q'
using (ExGen := ∅, SVSubst := ∅, KT := false)
well_formed q'
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
p': Pattern
Heqp': p' = AC.[□↦p]
q': Pattern
Heqq': q' = AC.[□↦q]
H: Γ ⊢i p0 $ AC.[□↦p or q] ---> p0 $ (p' or q')
using (ExGen := ∅, SVSubst := ∅, KT := false)
IH2: Γ ⊢i p' or q' ---> AC.[□↦p or q]
using (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> p' or q'
using (ExGen := ∅, SVSubst := ∅, KT := false)
well_formed p0 all: subst; try_wfauto2.
    +
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
i: ProofInfo
Heqi: i = (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q]
using i
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q]
using i
Γ
⊢i p0 $ AC.[□↦p] or p0 $ AC.[□↦q] --->
   p0 $ AC.[□↦p or q] using i eapply prf_disj_elim_meta_meta; try_wfauto2.
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
i: ProofInfo
Heqi: i = (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q]
using i
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q]
using i
Γ ⊢i p0 $ AC.[□↦p] ---> p0 $ AC.[□↦p or q] using i
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
i: ProofInfo
Heqi: i = (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q]
using i
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q]
using i
Γ ⊢i p0 $ AC.[□↦q] ---> p0 $ AC.[□↦p or q] using i
      *
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
i: ProofInfo
Heqi: i = (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q]
using i
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q]
using i
Γ ⊢i p0 $ AC.[□↦p] ---> p0 $ AC.[□↦p or q] using i subst i.
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q]
using (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q]
using (ExGen := ∅, SVSubst := ∅, KT := false)
Γ ⊢i p0 $ AC.[□↦p] ---> p0 $ AC.[□↦p or q]
using (ExGen := ∅, SVSubst := ∅, KT := false)
        apply Framing_right with (ψ := p0); auto.
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q]
using (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q]
using (ExGen := ∅, SVSubst := ∅, KT := false)
ProofInfoLe (ExGen := ∅, SVSubst := ∅, KT := false)
  (ExGen := ∅, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q]
using (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q]
using (ExGen := ∅, SVSubst := ∅, KT := false)
Γ ⊢i AC.[□↦p] ---> AC.[□↦p or q]
using (ExGen := ∅, SVSubst := ∅, KT := false)
        {
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q]
using (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q]
using (ExGen := ∅, SVSubst := ∅, KT := false)
ProofInfoLe (ExGen := ∅, SVSubst := ∅, KT := false)
  (ExGen := ∅, SVSubst := ∅, KT := false) try_solve_pile. }
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q]
using (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q]
using (ExGen := ∅, SVSubst := ∅, KT := false)
Γ ⊢i AC.[□↦p] ---> AC.[□↦p or q]
using (ExGen := ∅, SVSubst := ∅, KT := false)
        eapply prf_weaken_conclusion_meta_meta.
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q]
using (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q]
using (ExGen := ∅, SVSubst := ∅, KT := false)
well_formed AC.[□↦p]
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q]
using (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q]
using (ExGen := ∅, SVSubst := ∅, KT := false)
well_formed ?B
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q]
using (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q]
using (ExGen := ∅, SVSubst := ∅, KT := false)
well_formed AC.[□↦p or q]
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q]
using (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q]
using (ExGen := ∅, SVSubst := ∅, KT := false)
Γ ⊢i ?B ---> AC.[□↦p or q]
using (ExGen := ∅, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q]
using (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q]
using (ExGen := ∅, SVSubst := ∅, KT := false)
Γ ⊢i AC.[□↦p] ---> ?B
using (ExGen := ∅, SVSubst := ∅, KT := false)
        4: gapply IH2; try_solve_pile.
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q]
using (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q]
using (ExGen := ∅, SVSubst := ∅, KT := false)
well_formed AC.[□↦p]
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q]
using (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q]
using (ExGen := ∅, SVSubst := ∅, KT := false)
well_formed (AC.[□↦p] or AC.[□↦q])
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q]
using (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q]
using (ExGen := ∅, SVSubst := ∅, KT := false)
well_formed AC.[□↦p or q]
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q]
using (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q]
using (ExGen := ∅, SVSubst := ∅, KT := false)
Γ ⊢i AC.[□↦p] ---> AC.[□↦p] or AC.[□↦q]
using (ExGen := ∅, SVSubst := ∅, KT := false) all: try_wfauto2.
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q]
using (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q]
using (ExGen := ∅, SVSubst := ∅, KT := false)
Γ ⊢i AC.[□↦p] ---> AC.[□↦p] or AC.[□↦q]
using (ExGen := ∅, SVSubst := ∅, KT := false)
        useBasicReasoning.
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q]
using (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q]
using (ExGen := ∅, SVSubst := ∅, KT := false)
Γ ⊢i AC.[□↦p] ---> AC.[□↦p] or AC.[□↦q]
using BasicReasoning
        apply disj_left_intro; wf_auto2.
      *
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
i: ProofInfo
Heqi: i = (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q]
using i
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q]
using i
Γ ⊢i p0 $ AC.[□↦q] ---> p0 $ AC.[□↦p or q] using i subst i.
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q]
using (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q]
using (ExGen := ∅, SVSubst := ∅, KT := false)
Γ ⊢i p0 $ AC.[□↦q] ---> p0 $ AC.[□↦p or q]
using (ExGen := ∅, SVSubst := ∅, KT := false)
        apply Framing_right with (ψ := p0); auto.
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q]
using (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q]
using (ExGen := ∅, SVSubst := ∅, KT := false)
ProofInfoLe (ExGen := ∅, SVSubst := ∅, KT := false)
  (ExGen := ∅, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q]
using (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q]
using (ExGen := ∅, SVSubst := ∅, KT := false)
Γ ⊢i AC.[□↦q] ---> AC.[□↦p or q]
using (ExGen := ∅, SVSubst := ∅, KT := false)
        {
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q]
using (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q]
using (ExGen := ∅, SVSubst := ∅, KT := false)
ProofInfoLe (ExGen := ∅, SVSubst := ∅, KT := false)
  (ExGen := ∅, SVSubst := ∅, KT := false) try_solve_pile. }
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q]
using (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q]
using (ExGen := ∅, SVSubst := ∅, KT := false)
Γ ⊢i AC.[□↦q] ---> AC.[□↦p or q]
using (ExGen := ∅, SVSubst := ∅, KT := false)
        eapply prf_weaken_conclusion_meta_meta.
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q]
using (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q]
using (ExGen := ∅, SVSubst := ∅, KT := false)
well_formed AC.[□↦q]
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q]
using (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q]
using (ExGen := ∅, SVSubst := ∅, KT := false)
well_formed ?B
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q]
using (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q]
using (ExGen := ∅, SVSubst := ∅, KT := false)
well_formed AC.[□↦p or q]
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q]
using (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q]
using (ExGen := ∅, SVSubst := ∅, KT := false)
Γ ⊢i ?B ---> AC.[□↦p or q]
using (ExGen := ∅, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q]
using (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q]
using (ExGen := ∅, SVSubst := ∅, KT := false)
Γ ⊢i AC.[□↦q] ---> ?B
using (ExGen := ∅, SVSubst := ∅, KT := false)
        4: gapply IH2; try_solve_pile.
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q]
using (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q]
using (ExGen := ∅, SVSubst := ∅, KT := false)
well_formed AC.[□↦q]
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q]
using (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q]
using (ExGen := ∅, SVSubst := ∅, KT := false)
well_formed (AC.[□↦p] or AC.[□↦q])
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q]
using (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q]
using (ExGen := ∅, SVSubst := ∅, KT := false)
well_formed AC.[□↦p or q]
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q]
using (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q]
using (ExGen := ∅, SVSubst := ∅, KT := false)
Γ ⊢i AC.[□↦q] ---> AC.[□↦p] or AC.[□↦q]
using (ExGen := ∅, SVSubst := ∅, KT := false)
        all: try_wfauto2.
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q]
using (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q]
using (ExGen := ∅, SVSubst := ∅, KT := false)
Γ ⊢i AC.[□↦q] ---> AC.[□↦p] or AC.[□↦q]
using (ExGen := ∅, SVSubst := ∅, KT := false)
        useBasicReasoning.
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q]
using (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q]
using (ExGen := ∅, SVSubst := ∅, KT := false)
Γ ⊢i AC.[□↦q] ---> AC.[□↦p] or AC.[□↦q]
using BasicReasoning
        apply disj_right_intro; wf_auto2.
Defined.




Lemma Singleton_ctx {Σ : Signature} (Γ : Theory) (C1 C2 : Application_context) (ϕ : Pattern) (x : evar) :
  well_formed ϕ ->
  Γ ⊢i (! ((subst_ctx C1 (patt_free_evar x and ϕ)) and
             (subst_ctx C2 (patt_free_evar x and (! ϕ)))))
  using BasicReasoning.
Σ: Signature
Γ: Theory
C1, C2: Application_context
ϕ: Pattern
x: evar
well_formed ϕ
→ Γ
  ⊢i ! (C1.[□↦patt_free_evar x and ϕ]
        and C2.[□↦patt_free_evar x and ! ϕ])
  using BasicReasoning
Proof.
Σ: Signature
Γ: Theory
C1, C2: Application_context
ϕ: Pattern
x: evar
well_formed ϕ
→ Γ
  ⊢i ! (C1.[□↦patt_free_evar x and ϕ]
        and C2.[□↦patt_free_evar x and ! ϕ])
  using BasicReasoning
  intros Hwf.
Σ: Signature
Γ: Theory
C1, C2: Application_context
ϕ: Pattern
x: evar
Hwf: well_formed ϕ
Γ
⊢i ! (C1.[□↦patt_free_evar x and ϕ]
      and C2.[□↦patt_free_evar x and ! ϕ])
using BasicReasoning
  unshelve (eexists).
Σ: Signature
Γ: Theory
C1, C2: Application_context
ϕ: Pattern
x: evar
Hwf: well_formed ϕ
ML_proof_system Γ
  (! (C1.[□↦patt_free_evar x and ϕ]
      and C2.[□↦patt_free_evar x and ! ϕ]))
Σ: Signature
Γ: Theory
C1, C2: Application_context
ϕ: Pattern
x: evar
Hwf: well_formed ϕ
ProofInfoMeaning Γ
  (! (C1.[□↦patt_free_evar x and ϕ]
      and C2.[□↦patt_free_evar x and ! ϕ])) ?pf
  BasicReasoning
  {
Σ: Signature
Γ: Theory
C1, C2: Application_context
ϕ: Pattern
x: evar
Hwf: well_formed ϕ
ML_proof_system Γ
  (! (C1.[□↦patt_free_evar x and ϕ]
      and C2.[□↦patt_free_evar x and ! ϕ]))
    apply ProofSystem.Singleton_ctx.
Σ: Signature
Γ: Theory
C1, C2: Application_context
ϕ: Pattern
x: evar
Hwf: well_formed ϕ
well_formed ϕ apply Hwf.
  }
Σ: Signature
Γ: Theory
C1, C2: Application_context
ϕ: Pattern
x: evar
Hwf: well_formed ϕ
ProofInfoMeaning Γ
  (! (C1.[□↦patt_free_evar x and ϕ]
      and C2.[□↦patt_free_evar x and ! ϕ]))
  (Singleton_ctx Γ C1 C2 ϕ x Hwf) BasicReasoning
  {
Σ: Signature
Γ: Theory
C1, C2: Application_context
ϕ: Pattern
x: evar
Hwf: well_formed ϕ
ProofInfoMeaning Γ
  (! (C1.[□↦patt_free_evar x and ϕ]
      and C2.[□↦patt_free_evar x and ! ϕ]))
  (Singleton_ctx Γ C1 C2 ϕ x Hwf) BasicReasoning
    abstract (solve_pim_simple).
  }
Defined.

Lemma Existence {Σ : Signature} (Γ : Theory) :
  Γ ⊢i (ex , patt_bound_evar 0) using BasicReasoning.
Σ: Signature
Γ: Theory
Γ ⊢i ex , b0 using BasicReasoning
Proof.
Σ: Signature
Γ: Theory
Γ ⊢i ex , b0 using BasicReasoning
  unshelve (eexists).
Σ: Signature
Γ: Theory
ML_proof_system Γ (ex , b0)
Σ: Signature
Γ: Theory
ProofInfoMeaning Γ (ex , b0) ?pf BasicReasoning
  {
Σ: Signature
Γ: Theory
ML_proof_system Γ (ex , b0)
    apply ProofSystem.Existence.
  }
Σ: Signature
Γ: Theory
ProofInfoMeaning Γ (ex , b0) (Existence Γ)
  BasicReasoning
  {
Σ: Signature
Γ: Theory
ProofInfoMeaning Γ (ex , b0) (Existence Γ)
  BasicReasoning
    abstract (solve_pim_simple).
  }
Defined.

Lemma Prop_ex_left {Σ : Signature} (Γ : Theory) (ϕ ψ : Pattern) :
  well_formed (ex, ϕ) ->
  well_formed ψ ->
  Γ ⊢i (ex , ϕ) $ ψ ---> ex , ϕ $ ψ
  using BasicReasoning.
Σ: Signature
Γ: Theory
ϕ, ψ: Pattern
well_formed (ex , ϕ)
→ well_formed ψ
  → Γ ⊢i (ex , ϕ) $ ψ ---> (ex , ϕ $ ψ)
    using BasicReasoning
Proof.
Σ: Signature
Γ: Theory
ϕ, ψ: Pattern
well_formed (ex , ϕ)
→ well_formed ψ
  → Γ ⊢i (ex , ϕ) $ ψ ---> (ex , ϕ $ ψ)
    using BasicReasoning
  intros wfϕ wfψ.
Σ: Signature
Γ: Theory
ϕ, ψ: Pattern
wfϕ: well_formed (ex , ϕ)
wfψ: well_formed ψ
Γ ⊢i (ex , ϕ) $ ψ ---> (ex , ϕ $ ψ)
using BasicReasoning
  unshelve (eexists).
Σ: Signature
Γ: Theory
ϕ, ψ: Pattern
wfϕ: well_formed (ex , ϕ)
wfψ: well_formed ψ
ML_proof_system Γ ((ex , ϕ) $ ψ ---> (ex , ϕ $ ψ))
Σ: Signature
Γ: Theory
ϕ, ψ: Pattern
wfϕ: well_formed (ex , ϕ)
wfψ: well_formed ψ
ProofInfoMeaning Γ ((ex , ϕ) $ ψ ---> (ex , ϕ $ ψ))
  ?pf BasicReasoning
  {
Σ: Signature
Γ: Theory
ϕ, ψ: Pattern
wfϕ: well_formed (ex , ϕ)
wfψ: well_formed ψ
ML_proof_system Γ ((ex , ϕ) $ ψ ---> (ex , ϕ $ ψ))
    apply ProofSystem.Prop_ex_left.
Σ: Signature
Γ: Theory
ϕ, ψ: Pattern
wfϕ: well_formed (ex , ϕ)
wfψ: well_formed ψ
well_formed (ex , ϕ)
Σ: Signature
Γ: Theory
ϕ, ψ: Pattern
wfϕ: well_formed (ex , ϕ)
wfψ: well_formed ψ
well_formed ψ
    {
Σ: Signature
Γ: Theory
ϕ, ψ: Pattern
wfϕ: well_formed (ex , ϕ)
wfψ: well_formed ψ
well_formed (ex , ϕ) exact wfϕ. }
Σ: Signature
Γ: Theory
ϕ, ψ: Pattern
wfϕ: well_formed (ex , ϕ)
wfψ: well_formed ψ
well_formed ψ
    {
Σ: Signature
Γ: Theory
ϕ, ψ: Pattern
wfϕ: well_formed (ex , ϕ)
wfψ: well_formed ψ
well_formed ψ exact wfψ. }
  }
Σ: Signature
Γ: Theory
ϕ, ψ: Pattern
wfϕ: well_formed (ex , ϕ)
wfψ: well_formed ψ
ProofInfoMeaning Γ ((ex , ϕ) $ ψ ---> (ex , ϕ $ ψ))
  (Prop_ex_left Γ ϕ ψ wfϕ wfψ) BasicReasoning
  {
Σ: Signature
Γ: Theory
ϕ, ψ: Pattern
wfϕ: well_formed (ex , ϕ)
wfψ: well_formed ψ
ProofInfoMeaning Γ ((ex , ϕ) $ ψ ---> (ex , ϕ $ ψ))
  (Prop_ex_left Γ ϕ ψ wfϕ wfψ) BasicReasoning abstract(solve_pim_simple). }
Defined.

Lemma Prop_ex_right {Σ : Signature} (Γ : Theory) (ϕ ψ : Pattern) :
  well_formed (ex, ϕ) ->
  well_formed ψ ->
  Γ ⊢i ψ $ (ex , ϕ) ---> ex , ψ $ ϕ
  using BasicReasoning.
Σ: Signature
Γ: Theory
ϕ, ψ: Pattern
well_formed (ex , ϕ)
→ well_formed ψ
  → Γ ⊢i ψ $ (ex , ϕ) ---> (ex , ψ $ ϕ)
    using BasicReasoning
Proof.
Σ: Signature
Γ: Theory
ϕ, ψ: Pattern
well_formed (ex , ϕ)
→ well_formed ψ
  → Γ ⊢i ψ $ (ex , ϕ) ---> (ex , ψ $ ϕ)
    using BasicReasoning
  intros wfϕ wfψ.
Σ: Signature
Γ: Theory
ϕ, ψ: Pattern
wfϕ: well_formed (ex , ϕ)
wfψ: well_formed ψ
Γ ⊢i ψ $ (ex , ϕ) ---> (ex , ψ $ ϕ)
using BasicReasoning
  unshelve (eexists).
Σ: Signature
Γ: Theory
ϕ, ψ: Pattern
wfϕ: well_formed (ex , ϕ)
wfψ: well_formed ψ
ML_proof_system Γ (ψ $ (ex , ϕ) ---> (ex , ψ $ ϕ))
Σ: Signature
Γ: Theory
ϕ, ψ: Pattern
wfϕ: well_formed (ex , ϕ)
wfψ: well_formed ψ
ProofInfoMeaning Γ (ψ $ (ex , ϕ) ---> (ex , ψ $ ϕ))
  ?pf BasicReasoning
  {
Σ: Signature
Γ: Theory
ϕ, ψ: Pattern
wfϕ: well_formed (ex , ϕ)
wfψ: well_formed ψ
ML_proof_system Γ (ψ $ (ex , ϕ) ---> (ex , ψ $ ϕ))
    apply ProofSystem.Prop_ex_right.
Σ: Signature
Γ: Theory
ϕ, ψ: Pattern
wfϕ: well_formed (ex , ϕ)
wfψ: well_formed ψ
well_formed (ex , ϕ)
Σ: Signature
Γ: Theory
ϕ, ψ: Pattern
wfϕ: well_formed (ex , ϕ)
wfψ: well_formed ψ
well_formed ψ
    {
Σ: Signature
Γ: Theory
ϕ, ψ: Pattern
wfϕ: well_formed (ex , ϕ)
wfψ: well_formed ψ
well_formed (ex , ϕ) exact wfϕ. }
Σ: Signature
Γ: Theory
ϕ, ψ: Pattern
wfϕ: well_formed (ex , ϕ)
wfψ: well_formed ψ
well_formed ψ
    {
Σ: Signature
Γ: Theory
ϕ, ψ: Pattern
wfϕ: well_formed (ex , ϕ)
wfψ: well_formed ψ
well_formed ψ exact wfψ. }
  }
Σ: Signature
Γ: Theory
ϕ, ψ: Pattern
wfϕ: well_formed (ex , ϕ)
wfψ: well_formed ψ
ProofInfoMeaning Γ (ψ $ (ex , ϕ) ---> (ex , ψ $ ϕ))
  (Prop_ex_right Γ ϕ ψ wfϕ wfψ) BasicReasoning
  {
Σ: Signature
Γ: Theory
ϕ, ψ: Pattern
wfϕ: well_formed (ex , ϕ)
wfψ: well_formed ψ
ProofInfoMeaning Γ (ψ $ (ex , ϕ) ---> (ex , ψ $ ϕ))
  (Prop_ex_right Γ ϕ ψ wfϕ wfψ) BasicReasoning abstract(solve_pim_simple). }
Defined.


Tactic Notation "change" "constraint" "in" ident(H) :=
  let i := fresh "i" in
  remember_constraint as i;
  eapply useGenericReasoning with (i := i) in H;
  subst i;
  [|(try_solve_pile)].
 

Lemma prf_prop_ex_iff {Σ : Signature} Γ AC p x:
  evar_is_fresh_in x (subst_ctx AC p) ->
  well_formed (patt_exists p) = true ->
  Γ ⊢i ((subst_ctx AC (patt_exists p)) <---> (exists_quantify x (subst_ctx AC (p^{evar: 0 ↦ x}))))
  using (
  {| pi_generalized_evars := {[x]};
     pi_substituted_svars := ∅;
     pi_uses_kt := false ;
  |}).
Σ: Signature
Γ: Theory
AC: Application_context
p: Pattern
x: evar
evar_is_fresh_in x AC.[□↦p]
→ well_formed (ex , p) = true
  → Γ
    ⊢i AC.[□↦ex , p] <--->
       exists_quantify x AC.[□↦p^{evar:0↦x}]
    using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Proof.
Σ: Signature
Γ: Theory
AC: Application_context
p: Pattern
x: evar
evar_is_fresh_in x AC.[□↦p]
→ well_formed (ex , p) = true
  → Γ
    ⊢i AC.[□↦ex , p] <--->
       exists_quantify x AC.[□↦p^{evar:0↦x}]
    using (ExGen := {[x]}, SVSubst := ∅, KT := false)
  intros Hx Hwf.
Σ: Signature
Γ: Theory
AC: Application_context
p: Pattern
x: evar
Hx: evar_is_fresh_in x AC.[□↦p]
Hwf: well_formed (ex , p) = true
Γ
⊢i AC.[□↦ex , p] <--->
   exists_quantify x AC.[□↦p^{evar:0↦x}]
using (ExGen := {[x]}, SVSubst := ∅, KT := false)

  induction AC; simpl.
Σ: Signature
Γ: Theory
p: Pattern
x: evar
Hx: evar_is_fresh_in x □.[□↦p]
Hwf: well_formed (ex , p) = true
Γ ⊢i (ex , p) <---> exists_quantify x p^{evar:0↦x}
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC $ₗ p0).[□↦p]
Hwf: well_formed (ex , p) = true
IHAC: evar_is_fresh_in x AC.[□↦p]
→ Γ
  ⊢i AC.[□↦ex , p] <--->
     exists_quantify x AC.[□↦p^{evar:0↦x}]
  using (ExGen := {[x]}, SVSubst := ∅,
         KT := false)
Γ
⊢i AC.[□↦ex , p] $ p0 <--->
   exists_quantify x (AC.[□↦p^{evar:0↦x}] $ p0)
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (p0 $ᵣ AC).[□↦p]
Hwf: well_formed (ex , p) = true
IHAC: evar_is_fresh_in x AC.[□↦p]
→ Γ
  ⊢i AC.[□↦ex , p] <--->
     exists_quantify x AC.[□↦p^{evar:0↦x}]
  using (ExGen := {[x]}, SVSubst := ∅,
         KT := false)
Γ
⊢i p0 $ AC.[□↦ex , p] <--->
   exists_quantify x (p0 $ AC.[□↦p^{evar:0↦x}])
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
  -
Σ: Signature
Γ: Theory
p: Pattern
x: evar
Hx: evar_is_fresh_in x □.[□↦p]
Hwf: well_formed (ex , p) = true
Γ ⊢i (ex , p) <---> exists_quantify x p^{evar:0↦x}
using (ExGen := {[x]}, SVSubst := ∅, KT := false) simpl in Hx.
Σ: Signature
Γ: Theory
p: Pattern
x: evar
Hx: evar_is_fresh_in x p
Hwf: well_formed (ex , p) = true
Γ ⊢i (ex , p) <---> exists_quantify x p^{evar:0↦x}
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
    unfold exists_quantify.
Σ: Signature
Γ: Theory
p: Pattern
x: evar
Hx: evar_is_fresh_in x p
Hwf: well_formed (ex , p) = true
Γ ⊢i (ex , p) <---> (ex , p^{evar:0↦x}^{{evar:x↦0}})
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
    erewrite evar_quantify_evar_open; auto.
Σ: Signature
Γ: Theory
p: Pattern
x: evar
Hx: evar_is_fresh_in x p
Hwf: well_formed (ex , p) = true
Γ ⊢i (ex , p) <---> (ex , p)
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
p: Pattern
x: evar
Hx: evar_is_fresh_in x p
Hwf: well_formed (ex , p) = true
well_formed_closed_ex_aux p 1 2: now do 2 apply andb_true_iff in Hwf as [_ Hwf].
Σ: Signature
Γ: Theory
p: Pattern
x: evar
Hx: evar_is_fresh_in x p
Hwf: well_formed (ex , p) = true
Γ ⊢i (ex , p) <---> (ex , p)
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
    useBasicReasoning.
Σ: Signature
Γ: Theory
p: Pattern
x: evar
Hx: evar_is_fresh_in x p
Hwf: well_formed (ex , p) = true
Γ ⊢i (ex , p) <---> (ex , p) using BasicReasoning
    apply pf_iff_equiv_refl.
Σ: Signature
Γ: Theory
p: Pattern
x: evar
Hx: evar_is_fresh_in x p
Hwf: well_formed (ex , p) = true
well_formed (ex , p) exact Hwf.
  -
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC $ₗ p0).[□↦p]
Hwf: well_formed (ex , p) = true
IHAC: evar_is_fresh_in x AC.[□↦p]
→ Γ
  ⊢i AC.[□↦ex , p] <--->
     exists_quantify x AC.[□↦p^{evar:0↦x}]
  using (ExGen := {[x]}, SVSubst := ∅,
         KT := false)
Γ
⊢i AC.[□↦ex , p] $ p0 <--->
   exists_quantify x (AC.[□↦p^{evar:0↦x}] $ p0)
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
    assert (Hwfex: well_formed (ex , subst_ctx AC p)).
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC $ₗ p0).[□↦p]
Hwf: well_formed (ex , p) = true
IHAC: evar_is_fresh_in x AC.[□↦p]
→ Γ
  ⊢i AC.[□↦ex , p] <--->
     exists_quantify x AC.[□↦p^{evar:0↦x}]
  using (ExGen := {[x]}, SVSubst := ∅,
         KT := false)
well_formed (ex , AC.[□↦p])
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC $ₗ p0).[□↦p]
Hwf: well_formed (ex , p) = true
IHAC: evar_is_fresh_in x AC.[□↦p]
→ Γ
  ⊢i AC.[□↦ex , p] <--->
     exists_quantify x AC.[□↦p^{evar:0↦x}]
  using (ExGen := {[x]}, SVSubst := ∅,
         KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Γ
⊢i AC.[□↦ex , p] $ p0 <--->
   exists_quantify x (AC.[□↦p^{evar:0↦x}] $ p0)
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
    {
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC $ₗ p0).[□↦p]
Hwf: well_formed (ex , p) = true
IHAC: evar_is_fresh_in x AC.[□↦p]
→ Γ
  ⊢i AC.[□↦ex , p] <--->
     exists_quantify x AC.[□↦p^{evar:0↦x}]
  using (ExGen := {[x]}, SVSubst := ∅,
         KT := false)
well_formed (ex , AC.[□↦p]) unfold well_formed.
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC $ₗ p0).[□↦p]
Hwf: well_formed (ex , p) = true
IHAC: evar_is_fresh_in x AC.[□↦p]
→ Γ
  ⊢i AC.[□↦ex , p] <--->
     exists_quantify x AC.[□↦p^{evar:0↦x}]
  using (ExGen := {[x]}, SVSubst := ∅,
         KT := false)
well_formed_positive (ex , AC.[□↦p]) &&
well_formed_closed (ex , AC.[□↦p]) simpl.
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC $ₗ p0).[□↦p]
Hwf: well_formed (ex , p) = true
IHAC: evar_is_fresh_in x AC.[□↦p]
→ Γ
  ⊢i AC.[□↦ex , p] <--->
     exists_quantify x AC.[□↦p^{evar:0↦x}]
  using (ExGen := {[x]}, SVSubst := ∅,
         KT := false)
well_formed_positive AC.[□↦p] &&
well_formed_closed (ex , AC.[□↦p])
      pose proof (Hwf' := Hwf).
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC $ₗ p0).[□↦p]
Hwf: well_formed (ex , p) = true
IHAC: evar_is_fresh_in x AC.[□↦p]
→ Γ
  ⊢i AC.[□↦ex , p] <--->
     exists_quantify x AC.[□↦p^{evar:0↦x}]
  using (ExGen := {[x]}, SVSubst := ∅,
         KT := false)
Hwf': well_formed (ex , p) = true
well_formed_positive AC.[□↦p] &&
well_formed_closed (ex , AC.[□↦p])
      unfold well_formed in Hwf.
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC $ₗ p0).[□↦p]
Hwf: well_formed_positive (ex , p) && well_formed_closed (ex , p) = true
IHAC: evar_is_fresh_in x AC.[□↦p]
→ Γ
  ⊢i AC.[□↦ex , p] <--->
     exists_quantify x AC.[□↦p^{evar:0↦x}]
  using (ExGen := {[x]}, SVSubst := ∅,
         KT := false)
Hwf': well_formed (ex , p) = true
well_formed_positive AC.[□↦p] &&
well_formed_closed (ex , AC.[□↦p]) simpl in Hwf.
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC $ₗ p0).[□↦p]
Hwf: well_formed_positive p && well_formed_closed (ex , p) = true
IHAC: evar_is_fresh_in x AC.[□↦p]
→ Γ
  ⊢i AC.[□↦ex , p] <--->
     exists_quantify x AC.[□↦p^{evar:0↦x}]
  using (ExGen := {[x]}, SVSubst := ∅,
         KT := false)
Hwf': well_formed (ex , p) = true
well_formed_positive AC.[□↦p] &&
well_formed_closed (ex , AC.[□↦p])
      apply andb_prop in Hwf.
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC $ₗ p0).[□↦p]
Hwf: well_formed_positive p = true ∧ well_formed_closed (ex , p) = true
IHAC: evar_is_fresh_in x AC.[□↦p]
→ Γ
  ⊢i AC.[□↦ex , p] <--->
     exists_quantify x AC.[□↦p^{evar:0↦x}]
  using (ExGen := {[x]}, SVSubst := ∅,
         KT := false)
Hwf': well_formed (ex , p) = true
well_formed_positive AC.[□↦p] &&
well_formed_closed (ex , AC.[□↦p]) destruct Hwf as [Hwfp Hwfc].
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC $ₗ p0).[□↦p]
Hwfp: well_formed_positive p = true
Hwfc: well_formed_closed (ex , p) = true
IHAC: evar_is_fresh_in x AC.[□↦p]
→ Γ
  ⊢i AC.[□↦ex , p] <--->
     exists_quantify x AC.[□↦p^{evar:0↦x}]
  using (ExGen := {[x]}, SVSubst := ∅,
         KT := false)
Hwf': well_formed (ex , p) = true
well_formed_positive AC.[□↦p] &&
well_formed_closed (ex , AC.[□↦p])
      apply (wp_sctx AC p) in Hwfp.
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC $ₗ p0).[□↦p]
Hwfp: well_formed_positive AC.[□↦p] = true
Hwfc: well_formed_closed (ex , p) = true
IHAC: evar_is_fresh_in x AC.[□↦p]
→ Γ
  ⊢i AC.[□↦ex , p] <--->
     exists_quantify x AC.[□↦p^{evar:0↦x}]
  using (ExGen := {[x]}, SVSubst := ∅,
         KT := false)
Hwf': well_formed (ex , p) = true
well_formed_positive AC.[□↦p] &&
well_formed_closed (ex , AC.[□↦p]) rewrite Hwfp.
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC $ₗ p0).[□↦p]
Hwfp: well_formed_positive AC.[□↦p] = true
Hwfc: well_formed_closed (ex , p) = true
IHAC: evar_is_fresh_in x AC.[□↦p]
→ Γ
  ⊢i AC.[□↦ex , p] <--->
     exists_quantify x AC.[□↦p^{evar:0↦x}]
  using (ExGen := {[x]}, SVSubst := ∅,
         KT := false)
Hwf': well_formed (ex , p) = true
true && well_formed_closed (ex , AC.[□↦p]) simpl.
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC $ₗ p0).[□↦p]
Hwfp: well_formed_positive AC.[□↦p] = true
Hwfc: well_formed_closed (ex , p) = true
IHAC: evar_is_fresh_in x AC.[□↦p]
→ Γ
  ⊢i AC.[□↦ex , p] <--->
     exists_quantify x AC.[□↦p^{evar:0↦x}]
  using (ExGen := {[x]}, SVSubst := ∅,
         KT := false)
Hwf': well_formed (ex , p) = true
well_formed_closed (ex , AC.[□↦p]) clear Hwfp.
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC $ₗ p0).[□↦p]
Hwfc: well_formed_closed (ex , p) = true
IHAC: evar_is_fresh_in x AC.[□↦p]
→ Γ
  ⊢i AC.[□↦ex , p] <--->
     exists_quantify x AC.[□↦p^{evar:0↦x}]
  using (ExGen := {[x]}, SVSubst := ∅,
         KT := false)
Hwf': well_formed (ex , p) = true
well_formed_closed (ex , AC.[□↦p])
      unfold well_formed_closed.
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC $ₗ p0).[□↦p]
Hwfc: well_formed_closed (ex , p) = true
IHAC: evar_is_fresh_in x AC.[□↦p]
→ Γ
  ⊢i AC.[□↦ex , p] <--->
     exists_quantify x AC.[□↦p^{evar:0↦x}]
  using (ExGen := {[x]}, SVSubst := ∅,
         KT := false)
Hwf': well_formed (ex , p) = true
well_formed_closed_mu_aux (ex , AC.[□↦p]) 0 &&
well_formed_closed_ex_aux (ex , AC.[□↦p]) 0 unfold well_formed_closed in Hwfc.
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC $ₗ p0).[□↦p]
Hwfc: well_formed_closed_mu_aux (ex , p) 0 &&
well_formed_closed_ex_aux (ex , p) 0 = true
IHAC: evar_is_fresh_in x AC.[□↦p]
→ Γ
  ⊢i AC.[□↦ex , p] <--->
     exists_quantify x AC.[□↦p^{evar:0↦x}]
  using (ExGen := {[x]}, SVSubst := ∅,
         KT := false)
Hwf': well_formed (ex , p) = true
well_formed_closed_mu_aux (ex , AC.[□↦p]) 0 &&
well_formed_closed_ex_aux (ex , AC.[□↦p]) 0 simpl in Hwfc.
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC $ₗ p0).[□↦p]
Hwfc: well_formed_closed_mu_aux p 0 &&
well_formed_closed_ex_aux p 1 = true
IHAC: evar_is_fresh_in x AC.[□↦p]
→ Γ
  ⊢i AC.[□↦ex , p] <--->
     exists_quantify x AC.[□↦p^{evar:0↦x}]
  using (ExGen := {[x]}, SVSubst := ∅,
         KT := false)
Hwf': well_formed (ex , p) = true
well_formed_closed_mu_aux (ex , AC.[□↦p]) 0 &&
well_formed_closed_ex_aux (ex , AC.[□↦p]) 0 simpl.
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC $ₗ p0).[□↦p]
Hwfc: well_formed_closed_mu_aux p 0 &&
well_formed_closed_ex_aux p 1 = true
IHAC: evar_is_fresh_in x AC.[□↦p]
→ Γ
  ⊢i AC.[□↦ex , p] <--->
     exists_quantify x AC.[□↦p^{evar:0↦x}]
  using (ExGen := {[x]}, SVSubst := ∅,
         KT := false)
Hwf': well_formed (ex , p) = true
well_formed_closed_mu_aux AC.[□↦p] 0 &&
well_formed_closed_ex_aux AC.[□↦p] 1
      split_and!.
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC $ₗ p0).[□↦p]
Hwfc: well_formed_closed_mu_aux p 0 &&
well_formed_closed_ex_aux p 1 = true
IHAC: evar_is_fresh_in x AC.[□↦p]
→ Γ
  ⊢i AC.[□↦ex , p] <--->
     exists_quantify x AC.[□↦p^{evar:0↦x}]
  using (ExGen := {[x]}, SVSubst := ∅,
         KT := false)
Hwf': well_formed (ex , p) = true
well_formed_closed_mu_aux AC.[□↦p] 0 = true
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC $ₗ p0).[□↦p]
Hwfc: well_formed_closed_mu_aux p 0 &&
well_formed_closed_ex_aux p 1 = true
IHAC: evar_is_fresh_in x AC.[□↦p]
→ Γ
  ⊢i AC.[□↦ex , p] <--->
     exists_quantify x AC.[□↦p^{evar:0↦x}]
  using (ExGen := {[x]}, SVSubst := ∅,
         KT := false)
Hwf': well_formed (ex , p) = true
well_formed_closed_ex_aux AC.[□↦p] 1 = true
      +
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC $ₗ p0).[□↦p]
Hwfc: well_formed_closed_mu_aux p 0 &&
well_formed_closed_ex_aux p 1 = true
IHAC: evar_is_fresh_in x AC.[□↦p]
→ Γ
  ⊢i AC.[□↦ex , p] <--->
     exists_quantify x AC.[□↦p^{evar:0↦x}]
  using (ExGen := {[x]}, SVSubst := ∅,
         KT := false)
Hwf': well_formed (ex , p) = true
well_formed_closed_mu_aux AC.[□↦p] 0 = true apply wcmu_sctx.
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC $ₗ p0).[□↦p]
Hwfc: well_formed_closed_mu_aux p 0 &&
well_formed_closed_ex_aux p 1 = true
IHAC: evar_is_fresh_in x AC.[□↦p]
→ Γ
  ⊢i AC.[□↦ex , p] <--->
     exists_quantify x AC.[□↦p^{evar:0↦x}]
  using (ExGen := {[x]}, SVSubst := ∅,
         KT := false)
Hwf': well_formed (ex , p) = true
well_formed_closed_mu_aux p 0 = true destruct_and!.
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC $ₗ p0).[□↦p]
H: well_formed_closed_mu_aux p 0 = true
H0: well_formed_closed_ex_aux p 1 = true
IHAC: evar_is_fresh_in x AC.[□↦p]
→ Γ
  ⊢i AC.[□↦ex , p] <--->
     exists_quantify x AC.[□↦p^{evar:0↦x}]
  using (ExGen := {[x]}, SVSubst := ∅,
         KT := false)
Hwf': well_formed (ex , p) = true
well_formed_closed_mu_aux p 0 = true assumption.
      +
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC $ₗ p0).[□↦p]
Hwfc: well_formed_closed_mu_aux p 0 &&
well_formed_closed_ex_aux p 1 = true
IHAC: evar_is_fresh_in x AC.[□↦p]
→ Γ
  ⊢i AC.[□↦ex , p] <--->
     exists_quantify x AC.[□↦p^{evar:0↦x}]
  using (ExGen := {[x]}, SVSubst := ∅,
         KT := false)
Hwf': well_formed (ex , p) = true
well_formed_closed_ex_aux AC.[□↦p] 1 = true apply wcex_sctx.
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC $ₗ p0).[□↦p]
Hwfc: well_formed_closed_mu_aux p 0 &&
well_formed_closed_ex_aux p 1 = true
IHAC: evar_is_fresh_in x AC.[□↦p]
→ Γ
  ⊢i AC.[□↦ex , p] <--->
     exists_quantify x AC.[□↦p^{evar:0↦x}]
  using (ExGen := {[x]}, SVSubst := ∅,
         KT := false)
Hwf': well_formed (ex , p) = true
well_formed_closed_ex_aux p 1 = true destruct_and!.
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC $ₗ p0).[□↦p]
H: well_formed_closed_mu_aux p 0 = true
H0: well_formed_closed_ex_aux p 1 = true
IHAC: evar_is_fresh_in x AC.[□↦p]
→ Γ
  ⊢i AC.[□↦ex , p] <--->
     exists_quantify x AC.[□↦p^{evar:0↦x}]
  using (ExGen := {[x]}, SVSubst := ∅,
         KT := false)
Hwf': well_formed (ex , p) = true
well_formed_closed_ex_aux p 1 = true assumption.
    }
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC $ₗ p0).[□↦p]
Hwf: well_formed (ex , p) = true
IHAC: evar_is_fresh_in x AC.[□↦p]
→ Γ
  ⊢i AC.[□↦ex , p] <--->
     exists_quantify x AC.[□↦p^{evar:0↦x}]
  using (ExGen := {[x]}, SVSubst := ∅,
         KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Γ
⊢i AC.[□↦ex , p] $ p0 <--->
   exists_quantify x (AC.[□↦p^{evar:0↦x}] $ p0)
using (ExGen := {[x]}, SVSubst := ∅, KT := false)

    assert(Hxfr1: evar_is_fresh_in x (subst_ctx AC p)).
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC $ₗ p0).[□↦p]
Hwf: well_formed (ex , p) = true
IHAC: evar_is_fresh_in x AC.[□↦p]
→ Γ
  ⊢i AC.[□↦ex , p] <--->
     exists_quantify x AC.[□↦p^{evar:0↦x}]
  using (ExGen := {[x]}, SVSubst := ∅,
         KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
evar_is_fresh_in x AC.[□↦p]
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC $ₗ p0).[□↦p]
Hwf: well_formed (ex , p) = true
IHAC: evar_is_fresh_in x AC.[□↦p]
→ Γ
  ⊢i AC.[□↦ex , p] <--->
     exists_quantify x AC.[□↦p^{evar:0↦x}]
  using (ExGen := {[x]}, SVSubst := ∅,
         KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Γ
⊢i AC.[□↦ex , p] $ p0 <--->
   exists_quantify x (AC.[□↦p^{evar:0↦x}] $ p0)
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
    {
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC $ₗ p0).[□↦p]
Hwf: well_formed (ex , p) = true
IHAC: evar_is_fresh_in x AC.[□↦p]
→ Γ
  ⊢i AC.[□↦ex , p] <--->
     exists_quantify x AC.[□↦p^{evar:0↦x}]
  using (ExGen := {[x]}, SVSubst := ∅,
         KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
evar_is_fresh_in x AC.[□↦p] simpl in Hx.
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC.[□↦p] $ p0)
Hwf: well_formed (ex , p) = true
IHAC: evar_is_fresh_in x AC.[□↦p]
→ Γ
  ⊢i AC.[□↦ex , p] <--->
     exists_quantify x AC.[□↦p^{evar:0↦x}]
  using (ExGen := {[x]}, SVSubst := ∅,
         KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
evar_is_fresh_in x AC.[□↦p]
      eapply evar_is_fresh_in_richer.
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC.[□↦p] $ p0)
Hwf: well_formed (ex , p) = true
IHAC: evar_is_fresh_in x AC.[□↦p]
→ Γ
  ⊢i AC.[□↦ex , p] <--->
     exists_quantify x AC.[□↦p^{evar:0↦x}]
  using (ExGen := {[x]}, SVSubst := ∅,
         KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
free_evars AC.[□↦p] ⊆ free_evars ?ϕ₂
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC.[□↦p] $ p0)
Hwf: well_formed (ex , p) = true
IHAC: evar_is_fresh_in x AC.[□↦p]
→ Γ
  ⊢i AC.[□↦ex , p] <--->
     exists_quantify x AC.[□↦p^{evar:0↦x}]
  using (ExGen := {[x]}, SVSubst := ∅,
         KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
evar_is_fresh_in x ?ϕ₂
      2: {
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC.[□↦p] $ p0)
Hwf: well_formed (ex , p) = true
IHAC: evar_is_fresh_in x AC.[□↦p]
→ Γ
  ⊢i AC.[□↦ex , p] <--->
     exists_quantify x AC.[□↦p^{evar:0↦x}]
  using (ExGen := {[x]}, SVSubst := ∅,
         KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
evar_is_fresh_in x ?ϕ₂ apply Hx. }
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC.[□↦p] $ p0)
Hwf: well_formed (ex , p) = true
IHAC: evar_is_fresh_in x AC.[□↦p]
→ Γ
  ⊢i AC.[□↦ex , p] <--->
     exists_quantify x AC.[□↦p^{evar:0↦x}]
  using (ExGen := {[x]}, SVSubst := ∅,
         KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
free_evars AC.[□↦p] ⊆ free_evars (AC.[□↦p] $ p0)
      solve_free_evars_inclusion 5.
    }
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC $ₗ p0).[□↦p]
Hwf: well_formed (ex , p) = true
IHAC: evar_is_fresh_in x AC.[□↦p]
→ Γ
  ⊢i AC.[□↦ex , p] <--->
     exists_quantify x AC.[□↦p^{evar:0↦x}]
  using (ExGen := {[x]}, SVSubst := ∅,
         KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Γ
⊢i AC.[□↦ex , p] $ p0 <--->
   exists_quantify x (AC.[□↦p^{evar:0↦x}] $ p0)
using (ExGen := {[x]}, SVSubst := ∅, KT := false)

    simpl in Hx.
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC.[□↦p] $ p0)
Hwf: well_formed (ex , p) = true
IHAC: evar_is_fresh_in x AC.[□↦p]
→ Γ
  ⊢i AC.[□↦ex , p] <--->
     exists_quantify x AC.[□↦p^{evar:0↦x}]
  using (ExGen := {[x]}, SVSubst := ∅,
         KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Γ
⊢i AC.[□↦ex , p] $ p0 <--->
   exists_quantify x (AC.[□↦p^{evar:0↦x}] $ p0)
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
    pose proof (Hxfr1' := Hxfr1).
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC.[□↦p] $ p0)
Hwf: well_formed (ex , p) = true
IHAC: evar_is_fresh_in x AC.[□↦p]
→ Γ
  ⊢i AC.[□↦ex , p] <--->
     exists_quantify x AC.[□↦p^{evar:0↦x}]
  using (ExGen := {[x]}, SVSubst := ∅,
         KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1, Hxfr1': evar_is_fresh_in x AC.[□↦p]
Γ
⊢i AC.[□↦ex , p] $ p0 <--->
   exists_quantify x (AC.[□↦p^{evar:0↦x}] $ p0)
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
    rewrite -> evar_is_fresh_in_subst_ctx in Hxfr1'.
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC.[□↦p] $ p0)
Hwf: well_formed (ex , p) = true
IHAC: evar_is_fresh_in x AC.[□↦p]
→ Γ
  ⊢i AC.[□↦ex , p] <--->
     exists_quantify x AC.[□↦p^{evar:0↦x}]
  using (ExGen := {[x]}, SVSubst := ∅,
         KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfr1': evar_is_fresh_in x p ∧ x ∉ AC_free_evars AC
Γ
⊢i AC.[□↦ex , p] $ p0 <--->
   exists_quantify x (AC.[□↦p^{evar:0↦x}] $ p0)
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
    destruct Hxfr1' as [Hxfrp HxAC].
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC.[□↦p] $ p0)
Hwf: well_formed (ex , p) = true
IHAC: evar_is_fresh_in x AC.[□↦p]
→ Γ
  ⊢i AC.[□↦ex , p] <--->
     exists_quantify x AC.[□↦p^{evar:0↦x}]
  using (ExGen := {[x]}, SVSubst := ∅,
         KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Γ
⊢i AC.[□↦ex , p] $ p0 <--->
   exists_quantify x (AC.[□↦p^{evar:0↦x}] $ p0)
using (ExGen := {[x]}, SVSubst := ∅, KT := false)

    assert(Hwf': well_formed (exists_quantify x (subst_ctx AC (p^{evar: 0 ↦ x})))).
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC.[□↦p] $ p0)
Hwf: well_formed (ex , p) = true
IHAC: evar_is_fresh_in x AC.[□↦p]
→ Γ
  ⊢i AC.[□↦ex , p] <--->
     exists_quantify x AC.[□↦p^{evar:0↦x}]
  using (ExGen := {[x]}, SVSubst := ∅,
         KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
well_formed (exists_quantify x AC.[□↦p^{evar:0↦x}])
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC.[□↦p] $ p0)
Hwf: well_formed (ex , p) = true
IHAC: evar_is_fresh_in x AC.[□↦p]
→ Γ
  ⊢i AC.[□↦ex , p] <--->
     exists_quantify x AC.[□↦p^{evar:0↦x}]
  using (ExGen := {[x]}, SVSubst := ∅,
         KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed
  (exists_quantify x AC.[□↦p^{evar:0↦x}])
Γ
⊢i AC.[□↦ex , p] $ p0 <--->
   exists_quantify x (AC.[□↦p^{evar:0↦x}] $ p0)
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
    {
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC.[□↦p] $ p0)
Hwf: well_formed (ex , p) = true
IHAC: evar_is_fresh_in x AC.[□↦p]
→ Γ
  ⊢i AC.[□↦ex , p] <--->
     exists_quantify x AC.[□↦p^{evar:0↦x}]
  using (ExGen := {[x]}, SVSubst := ∅,
         KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
well_formed (exists_quantify x AC.[□↦p^{evar:0↦x}])
      unfold exists_quantify.
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC.[□↦p] $ p0)
Hwf: well_formed (ex , p) = true
IHAC: evar_is_fresh_in x AC.[□↦p]
→ Γ
  ⊢i AC.[□↦ex , p] <--->
     exists_quantify x AC.[□↦p^{evar:0↦x}]
  using (ExGen := {[x]}, SVSubst := ∅,
         KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
well_formed (ex , AC.[□↦p^{evar:0↦x}]^{{evar:x↦0}})
      clear -HxAC Hwf.
Σ: Signature
AC: Application_context
p: Pattern
x: evar
Hwf: well_formed (ex , p) = true
HxAC: x ∉ AC_free_evars AC
well_formed (ex , AC.[□↦p^{evar:0↦x}]^{{evar:x↦0}})
      apply wf_ex_eq_sctx_eo.
Σ: Signature
AC: Application_context
p: Pattern
x: evar
Hwf: well_formed (ex , p) = true
HxAC: x ∉ AC_free_evars AC
well_formed (ex , p) = true
      apply Hwf.
    }
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC.[□↦p] $ p0)
Hwf: well_formed (ex , p) = true
IHAC: evar_is_fresh_in x AC.[□↦p]
→ Γ
  ⊢i AC.[□↦ex , p] <--->
     exists_quantify x AC.[□↦p^{evar:0↦x}]
  using (ExGen := {[x]}, SVSubst := ∅,
         KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed
  (exists_quantify x AC.[□↦p^{evar:0↦x}])
Γ
⊢i AC.[□↦ex , p] $ p0 <--->
   exists_quantify x (AC.[□↦p^{evar:0↦x}] $ p0)
using (ExGen := {[x]}, SVSubst := ∅, KT := false)

    assert (Hwfeo: well_formed (p^{evar: 0 ↦ x})).
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC.[□↦p] $ p0)
Hwf: well_formed (ex , p) = true
IHAC: evar_is_fresh_in x AC.[□↦p]
→ Γ
  ⊢i AC.[□↦ex , p] <--->
     exists_quantify x AC.[□↦p^{evar:0↦x}]
  using (ExGen := {[x]}, SVSubst := ∅,
         KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed
  (exists_quantify x AC.[□↦p^{evar:0↦x}])
well_formed p^{evar:0↦x}
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC.[□↦p] $ p0)
Hwf: well_formed (ex , p) = true
IHAC: evar_is_fresh_in x AC.[□↦p]
→ Γ
  ⊢i AC.[□↦ex , p] <--->
     exists_quantify x AC.[□↦p^{evar:0↦x}]
  using (ExGen := {[x]}, SVSubst := ∅,
         KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed
  (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Γ
⊢i AC.[□↦ex , p] $ p0 <--->
   exists_quantify x (AC.[□↦p^{evar:0↦x}] $ p0)
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
    {
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC.[□↦p] $ p0)
Hwf: well_formed (ex , p) = true
IHAC: evar_is_fresh_in x AC.[□↦p]
→ Γ
  ⊢i AC.[□↦ex , p] <--->
     exists_quantify x AC.[□↦p^{evar:0↦x}]
  using (ExGen := {[x]}, SVSubst := ∅,
         KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed
  (exists_quantify x AC.[□↦p^{evar:0↦x}])
well_formed p^{evar:0↦x} wf_auto2. }
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC.[□↦p] $ p0)
Hwf: well_formed (ex , p) = true
IHAC: evar_is_fresh_in x AC.[□↦p]
→ Γ
  ⊢i AC.[□↦ex , p] <--->
     exists_quantify x AC.[□↦p^{evar:0↦x}]
  using (ExGen := {[x]}, SVSubst := ∅,
         KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed
  (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Γ
⊢i AC.[□↦ex , p] $ p0 <--->
   exists_quantify x (AC.[□↦p^{evar:0↦x}] $ p0)
using (ExGen := {[x]}, SVSubst := ∅, KT := false)


    (* TODO automate this. The problem is that [well_formed_app] and others do not have [= true];
       that is why [auto] does not work. But [auto] is not suitable for this anyway.
       A better way would be to create some `simpl_well_formed` tuple, that might use the type class
       mechanism for extension...
     *)
    assert(Hwf'p0: well_formed (exists_quantify x (subst_ctx AC (p^{evar: 0 ↦ x}) $ p0))).
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC.[□↦p] $ p0)
Hwf: well_formed (ex , p) = true
IHAC: evar_is_fresh_in x AC.[□↦p]
→ Γ
  ⊢i AC.[□↦ex , p] <--->
     exists_quantify x AC.[□↦p^{evar:0↦x}]
  using (ExGen := {[x]}, SVSubst := ∅,
         KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed
  (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
well_formed
  (exists_quantify x (AC.[□↦p^{evar:0↦x}] $ p0))
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC.[□↦p] $ p0)
Hwf: well_formed (ex , p) = true
IHAC: evar_is_fresh_in x AC.[□↦p]
→ Γ
  ⊢i AC.[□↦ex , p] <--->
     exists_quantify x AC.[□↦p^{evar:0↦x}]
  using (ExGen := {[x]}, SVSubst := ∅,
         KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed
  (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed
  (exists_quantify x
     (AC.[□↦p^{evar:0↦x}] $ p0))
Γ
⊢i AC.[□↦ex , p] $ p0 <--->
   exists_quantify x (AC.[□↦p^{evar:0↦x}] $ p0)
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
    {
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC.[□↦p] $ p0)
Hwf: well_formed (ex , p) = true
IHAC: evar_is_fresh_in x AC.[□↦p]
→ Γ
  ⊢i AC.[□↦ex , p] <--->
     exists_quantify x AC.[□↦p^{evar:0↦x}]
  using (ExGen := {[x]}, SVSubst := ∅,
         KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed
  (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
well_formed
  (exists_quantify x (AC.[□↦p^{evar:0↦x}] $ p0)) wf_auto2. }
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC.[□↦p] $ p0)
Hwf: well_formed (ex , p) = true
IHAC: evar_is_fresh_in x AC.[□↦p]
→ Γ
  ⊢i AC.[□↦ex , p] <--->
     exists_quantify x AC.[□↦p^{evar:0↦x}]
  using (ExGen := {[x]}, SVSubst := ∅,
         KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed
  (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed
  (exists_quantify x
     (AC.[□↦p^{evar:0↦x}] $ p0))
Γ
⊢i AC.[□↦ex , p] $ p0 <--->
   exists_quantify x (AC.[□↦p^{evar:0↦x}] $ p0)
using (ExGen := {[x]}, SVSubst := ∅, KT := false)

    apply pf_iff_iff in IHAC; auto.
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC.[□↦p] $ p0)
Hwf: well_formed (ex , p) = true
IHAC: ((Γ
  ⊢i AC.[□↦ex , p] --->
     exists_quantify x AC.[□↦p^{evar:0↦x}]
  using (ExGen := {[x]}, SVSubst := ∅,
         KT := false)) *
 (Γ
  ⊢i exists_quantify x AC.[□↦p^{evar:0↦x}] --->
     AC.[□↦ex , p]
  using (ExGen := {[x]}, SVSubst := ∅,
         KT := false)))%type
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed
  (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed
  (exists_quantify x
     (AC.[□↦p^{evar:0↦x}] $ p0))
Γ
⊢i AC.[□↦ex , p] $ p0 <--->
   exists_quantify x (AC.[□↦p^{evar:0↦x}] $ p0)
using (ExGen := {[x]}, SVSubst := ∅, KT := false)

    destruct IHAC as [IH1 IH2].
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC.[□↦p] $ p0)
Hwf: well_formed (ex , p) = true
IH1: Γ ⊢i AC.[□↦ex , p] ---> exists_quantify x AC.[□↦p^{evar:0↦x}]
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
IH2: Γ ⊢i exists_quantify x AC.[□↦p^{evar:0↦x}] ---> AC.[□↦ex , p]
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed
  (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed
  (exists_quantify x
     (AC.[□↦p^{evar:0↦x}] $ p0))
Γ
⊢i AC.[□↦ex , p] $ p0 <--->
   exists_quantify x (AC.[□↦p^{evar:0↦x}] $ p0)
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
    apply pf_iff_split; auto.
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC.[□↦p] $ p0)
Hwf: well_formed (ex , p) = true
IH1: Γ ⊢i AC.[□↦ex , p] ---> exists_quantify x AC.[□↦p^{evar:0↦x}]
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
IH2: Γ ⊢i exists_quantify x AC.[□↦p^{evar:0↦x}] ---> AC.[□↦ex , p]
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed
  (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed
  (exists_quantify x
     (AC.[□↦p^{evar:0↦x}] $ p0))
Γ
⊢i AC.[□↦ex , p] $ p0 --->
   exists_quantify x (AC.[□↦p^{evar:0↦x}] $ p0)
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC.[□↦p] $ p0)
Hwf: well_formed (ex , p) = true
IH1: Γ
⊢i AC.[□↦ex , p] --->
   exists_quantify x AC.[□↦p^{evar:0↦x}]
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
IH2: Γ
⊢i exists_quantify x AC.[□↦p^{evar:0↦x}] --->
   AC.[□↦ex , p]
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed
  (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed
  (exists_quantify x
     (AC.[□↦p^{evar:0↦x}] $ p0))
Γ
⊢i exists_quantify x (AC.[□↦p^{evar:0↦x}] $ p0) --->
   AC.[□↦ex , p] $ p0
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
    +
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC.[□↦p] $ p0)
Hwf: well_formed (ex , p) = true
IH1: Γ ⊢i AC.[□↦ex , p] ---> exists_quantify x AC.[□↦p^{evar:0↦x}]
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
IH2: Γ ⊢i exists_quantify x AC.[□↦p^{evar:0↦x}] ---> AC.[□↦ex , p]
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed
  (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed
  (exists_quantify x
     (AC.[□↦p^{evar:0↦x}] $ p0))
Γ
⊢i AC.[□↦ex , p] $ p0 --->
   exists_quantify x (AC.[□↦p^{evar:0↦x}] $ p0)
using (ExGen := {[x]}, SVSubst := ∅, KT := false) pose proof (H := IH1).
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC.[□↦p] $ p0)
Hwf: well_formed (ex , p) = true
IH1: Γ ⊢i AC.[□↦ex , p] ---> exists_quantify x AC.[□↦p^{evar:0↦x}]
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
IH2: Γ ⊢i exists_quantify x AC.[□↦p^{evar:0↦x}] ---> AC.[□↦ex , p]
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed
  (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed
  (exists_quantify x
     (AC.[□↦p^{evar:0↦x}] $ p0))
H: Γ
⊢i AC.[□↦ex , p] --->
   exists_quantify x AC.[□↦p^{evar:0↦x}]
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Γ
⊢i AC.[□↦ex , p] $ p0 --->
   exists_quantify x (AC.[□↦p^{evar:0↦x}] $ p0)
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
      change constraint in IH1.
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC.[□↦p] $ p0)
Hwf: well_formed (ex , p) = true
IH2: Γ ⊢i exists_quantify x AC.[□↦p^{evar:0↦x}] ---> AC.[□↦ex , p]
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦ex , p] ---> exists_quantify x AC.[□↦p^{evar:0↦x}]
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed
  (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed
  (exists_quantify x
     (AC.[□↦p^{evar:0↦x}] $ p0))
H: Γ
⊢i AC.[□↦ex , p] --->
   exists_quantify x AC.[□↦p^{evar:0↦x}]
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Γ
⊢i AC.[□↦ex , p] $ p0 --->
   exists_quantify x (AC.[□↦p^{evar:0↦x}] $ p0)
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
      apply Framing_left with (ψ := p0) in IH1; auto.
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC.[□↦p] $ p0)
Hwf: well_formed (ex , p) = true
IH2: Γ ⊢i exists_quantify x AC.[□↦p^{evar:0↦x}] ---> AC.[□↦ex , p]
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦ex , p] $ p0 ---> exists_quantify x AC.[□↦p^{evar:0↦x}] $ p0
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed
  (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed
  (exists_quantify x
     (AC.[□↦p^{evar:0↦x}] $ p0))
H: Γ
⊢i AC.[□↦ex , p] --->
   exists_quantify x AC.[□↦p^{evar:0↦x}]
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Γ
⊢i AC.[□↦ex , p] $ p0 --->
   exists_quantify x (AC.[□↦p^{evar:0↦x}] $ p0)
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC.[□↦p] $ p0)
Hwf: well_formed (ex , p) = true
IH2: Γ
⊢i exists_quantify x AC.[□↦p^{evar:0↦x}] --->
   AC.[□↦ex , p]
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
IH1: Γ
⊢i AC.[□↦ex , p] --->
   exists_quantify x AC.[□↦p^{evar:0↦x}]
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed
  (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed
  (exists_quantify x
     (AC.[□↦p^{evar:0↦x}] $ p0))
H: Γ
⊢i AC.[□↦ex , p] --->
   exists_quantify x AC.[□↦p^{evar:0↦x}]
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
ProofInfoLe (ExGen := ∅, SVSubst := ∅, KT := false)
  (ExGen := {[x]}, SVSubst := ∅, KT := false)
      2: {
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC.[□↦p] $ p0)
Hwf: well_formed (ex , p) = true
IH2: Γ ⊢i exists_quantify x AC.[□↦p^{evar:0↦x}] ---> AC.[□↦ex , p]
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦ex , p] ---> exists_quantify x AC.[□↦p^{evar:0↦x}]
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed
  (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed
  (exists_quantify x
     (AC.[□↦p^{evar:0↦x}] $ p0))
H: Γ
⊢i AC.[□↦ex , p] --->
   exists_quantify x AC.[□↦p^{evar:0↦x}]
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
ProofInfoLe (ExGen := ∅, SVSubst := ∅, KT := false)
  (ExGen := {[x]}, SVSubst := ∅, KT := false) try_solve_pile. }
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC.[□↦p] $ p0)
Hwf: well_formed (ex , p) = true
IH2: Γ ⊢i exists_quantify x AC.[□↦p^{evar:0↦x}] ---> AC.[□↦ex , p]
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦ex , p] $ p0 ---> exists_quantify x AC.[□↦p^{evar:0↦x}] $ p0
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed
  (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed
  (exists_quantify x
     (AC.[□↦p^{evar:0↦x}] $ p0))
H: Γ
⊢i AC.[□↦ex , p] --->
   exists_quantify x AC.[□↦p^{evar:0↦x}]
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Γ
⊢i AC.[□↦ex , p] $ p0 --->
   exists_quantify x (AC.[□↦p^{evar:0↦x}] $ p0)
using (ExGen := {[x]}, SVSubst := ∅, KT := false)

      eapply syllogism_meta.
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC.[□↦p] $ p0)
Hwf: well_formed (ex , p) = true
IH2: Γ ⊢i exists_quantify x AC.[□↦p^{evar:0↦x}] ---> AC.[□↦ex , p]
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦ex , p] $ p0 ---> exists_quantify x AC.[□↦p^{evar:0↦x}] $ p0
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed
  (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed
  (exists_quantify x
     (AC.[□↦p^{evar:0↦x}] $ p0))
H: Γ
⊢i AC.[□↦ex , p] --->
   exists_quantify x AC.[□↦p^{evar:0↦x}]
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
well_formed (AC.[□↦ex , p] $ p0)
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC.[□↦p] $ p0)
Hwf: well_formed (ex , p) = true
IH2: Γ
⊢i exists_quantify x AC.[□↦p^{evar:0↦x}] --->
   AC.[□↦ex , p]
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
IH1: Γ
⊢i AC.[□↦ex , p] $ p0 --->
   exists_quantify x AC.[□↦p^{evar:0↦x}] $ p0
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed
  (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed
  (exists_quantify x
     (AC.[□↦p^{evar:0↦x}] $ p0))
H: Γ
⊢i AC.[□↦ex , p] --->
   exists_quantify x AC.[□↦p^{evar:0↦x}]
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
well_formed ?B
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC.[□↦p] $ p0)
Hwf: well_formed (ex , p) = true
IH2: Γ
⊢i exists_quantify x AC.[□↦p^{evar:0↦x}] --->
   AC.[□↦ex , p]
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
IH1: Γ
⊢i AC.[□↦ex , p] $ p0 --->
   exists_quantify x AC.[□↦p^{evar:0↦x}] $ p0
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed
  (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed
  (exists_quantify x
     (AC.[□↦p^{evar:0↦x}] $ p0))
H: Γ
⊢i AC.[□↦ex , p] --->
   exists_quantify x AC.[□↦p^{evar:0↦x}]
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
well_formed
  (exists_quantify x (AC.[□↦p^{evar:0↦x}] $ p0))
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC.[□↦p] $ p0)
Hwf: well_formed (ex , p) = true
IH2: Γ
⊢i exists_quantify x AC.[□↦p^{evar:0↦x}] --->
   AC.[□↦ex , p]
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
IH1: Γ
⊢i AC.[□↦ex , p] $ p0 --->
   exists_quantify x AC.[□↦p^{evar:0↦x}] $ p0
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed
  (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed
  (exists_quantify x
     (AC.[□↦p^{evar:0↦x}] $ p0))
H: Γ
⊢i AC.[□↦ex , p] --->
   exists_quantify x AC.[□↦p^{evar:0↦x}]
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Γ ⊢i AC.[□↦ex , p] $ p0 ---> ?B
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC.[□↦p] $ p0)
Hwf: well_formed (ex , p) = true
IH2: Γ
⊢i exists_quantify x AC.[□↦p^{evar:0↦x}] --->
   AC.[□↦ex , p]
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
IH1: Γ
⊢i AC.[□↦ex , p] $ p0 --->
   exists_quantify x AC.[□↦p^{evar:0↦x}] $ p0
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed
  (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed
  (exists_quantify x
     (AC.[□↦p^{evar:0↦x}] $ p0))
H: Γ
⊢i AC.[□↦ex , p] --->
   exists_quantify x AC.[□↦p^{evar:0↦x}]
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Γ
⊢i ?B --->
   exists_quantify x (AC.[□↦p^{evar:0↦x}] $ p0)
using (ExGen := {[x]}, SVSubst := ∅, KT := false) 4: apply IH1.
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC.[□↦p] $ p0)
Hwf: well_formed (ex , p) = true
IH2: Γ ⊢i exists_quantify x AC.[□↦p^{evar:0↦x}] ---> AC.[□↦ex , p]
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦ex , p] $ p0 ---> exists_quantify x AC.[□↦p^{evar:0↦x}] $ p0
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed
  (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed
  (exists_quantify x
     (AC.[□↦p^{evar:0↦x}] $ p0))
H: Γ
⊢i AC.[□↦ex , p] --->
   exists_quantify x AC.[□↦p^{evar:0↦x}]
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
well_formed (AC.[□↦ex , p] $ p0)
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC.[□↦p] $ p0)
Hwf: well_formed (ex , p) = true
IH2: Γ
⊢i exists_quantify x AC.[□↦p^{evar:0↦x}] --->
   AC.[□↦ex , p]
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
IH1: Γ
⊢i AC.[□↦ex , p] $ p0 --->
   exists_quantify x AC.[□↦p^{evar:0↦x}] $ p0
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed
  (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed
  (exists_quantify x
     (AC.[□↦p^{evar:0↦x}] $ p0))
H: Γ
⊢i AC.[□↦ex , p] --->
   exists_quantify x AC.[□↦p^{evar:0↦x}]
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
well_formed
  (exists_quantify x AC.[□↦p^{evar:0↦x}] $ p0)
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC.[□↦p] $ p0)
Hwf: well_formed (ex , p) = true
IH2: Γ
⊢i exists_quantify x AC.[□↦p^{evar:0↦x}] --->
   AC.[□↦ex , p]
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
IH1: Γ
⊢i AC.[□↦ex , p] $ p0 --->
   exists_quantify x AC.[□↦p^{evar:0↦x}] $ p0
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed
  (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed
  (exists_quantify x
     (AC.[□↦p^{evar:0↦x}] $ p0))
H: Γ
⊢i AC.[□↦ex , p] --->
   exists_quantify x AC.[□↦p^{evar:0↦x}]
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
well_formed
  (exists_quantify x (AC.[□↦p^{evar:0↦x}] $ p0))
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC.[□↦p] $ p0)
Hwf: well_formed (ex , p) = true
IH2: Γ
⊢i exists_quantify x AC.[□↦p^{evar:0↦x}] --->
   AC.[□↦ex , p]
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
IH1: Γ
⊢i AC.[□↦ex , p] $ p0 --->
   exists_quantify x AC.[□↦p^{evar:0↦x}] $ p0
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed
  (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed
  (exists_quantify x
     (AC.[□↦p^{evar:0↦x}] $ p0))
H: Γ
⊢i AC.[□↦ex , p] --->
   exists_quantify x AC.[□↦p^{evar:0↦x}]
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Γ
⊢i exists_quantify x AC.[□↦p^{evar:0↦x}] $ p0 --->
   exists_quantify x (AC.[□↦p^{evar:0↦x}] $ p0)
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
      1-3: wf_auto2.
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC.[□↦p] $ p0)
Hwf: well_formed (ex , p) = true
IH2: Γ ⊢i exists_quantify x AC.[□↦p^{evar:0↦x}] ---> AC.[□↦ex , p]
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦ex , p] $ p0 ---> exists_quantify x AC.[□↦p^{evar:0↦x}] $ p0
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed
  (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed
  (exists_quantify x
     (AC.[□↦p^{evar:0↦x}] $ p0))
H: Γ
⊢i AC.[□↦ex , p] --->
   exists_quantify x AC.[□↦p^{evar:0↦x}]
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Γ
⊢i exists_quantify x AC.[□↦p^{evar:0↦x}] $ p0 --->
   exists_quantify x (AC.[□↦p^{evar:0↦x}] $ p0)
using (ExGen := {[x]}, SVSubst := ∅, KT := false)

      remember (subst_ctx AC (p^{evar: 0 ↦ x})) as p'.
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC.[□↦p] $ p0)
Hwf: well_formed (ex , p) = true
p': Pattern
Heqp': p' = AC.[□↦p^{evar:0↦x}]
IH2: Γ ⊢i exists_quantify x p' ---> AC.[□↦ex , p]
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
IH1: Γ
⊢i AC.[□↦ex , p] $ p0 --->
   exists_quantify x p' $ p0
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed (exists_quantify x p')
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed (exists_quantify x (p' $ p0))
H: Γ ⊢i AC.[□↦ex , p] ---> exists_quantify x p'
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Γ
⊢i exists_quantify x p' $ p0 --->
   exists_quantify x (p' $ p0)
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
      unfold exists_quantify.
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC.[□↦p] $ p0)
Hwf: well_formed (ex , p) = true
p': Pattern
Heqp': p' = AC.[□↦p^{evar:0↦x}]
IH2: Γ ⊢i exists_quantify x p' ---> AC.[□↦ex , p]
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
IH1: Γ
⊢i AC.[□↦ex , p] $ p0 --->
   exists_quantify x p' $ p0
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed (exists_quantify x p')
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed (exists_quantify x (p' $ p0))
H: Γ ⊢i AC.[□↦ex , p] ---> exists_quantify x p'
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Γ
⊢i (ex , p'^{{evar:x↦0}}) $ p0 --->
   (ex , (p' $ p0)^{{evar:x↦0}})
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
      simpl.
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC.[□↦p] $ p0)
Hwf: well_formed (ex , p) = true
p': Pattern
Heqp': p' = AC.[□↦p^{evar:0↦x}]
IH2: Γ ⊢i exists_quantify x p' ---> AC.[□↦ex , p]
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
IH1: Γ
⊢i AC.[□↦ex , p] $ p0 --->
   exists_quantify x p' $ p0
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed (exists_quantify x p')
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed (exists_quantify x (p' $ p0))
H: Γ ⊢i AC.[□↦ex , p] ---> exists_quantify x p'
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Γ
⊢i (ex , p'^{{evar:x↦0}}) $ p0 --->
   (ex , p'^{{evar:x↦0}} $ p0^{{evar:x↦0}})
using (ExGen := {[x]}, SVSubst := ∅, KT := false) rewrite [p0^{{evar: x ↦ 0}}]evar_quantify_fresh.
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC.[□↦p] $ p0)
Hwf: well_formed (ex , p) = true
p': Pattern
Heqp': p' = AC.[□↦p^{evar:0↦x}]
IH2: Γ ⊢i exists_quantify x p' ---> AC.[□↦ex , p]
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
IH1: Γ
⊢i AC.[□↦ex , p] $ p0 --->
   exists_quantify x p' $ p0
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed (exists_quantify x p')
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed (exists_quantify x (p' $ p0))
H: Γ ⊢i AC.[□↦ex , p] ---> exists_quantify x p'
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
evar_is_fresh_in x p0
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC.[□↦p] $ p0)
Hwf: well_formed (ex , p) = true
p': Pattern
Heqp': p' = AC.[□↦p^{evar:0↦x}]
IH2: Γ ⊢i exists_quantify x p' ---> AC.[□↦ex , p]
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
IH1: Γ
⊢i AC.[□↦ex , p] $ p0 --->
   exists_quantify x p' $ p0
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed (exists_quantify x p')
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed (exists_quantify x (p' $ p0))
H: Γ ⊢i AC.[□↦ex , p] ---> exists_quantify x p'
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Γ
⊢i (ex , p'^{{evar:x↦0}}) $ p0 --->
   (ex , p'^{{evar:x↦0}} $ p0)
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
      {
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC.[□↦p] $ p0)
Hwf: well_formed (ex , p) = true
p': Pattern
Heqp': p' = AC.[□↦p^{evar:0↦x}]
IH2: Γ ⊢i exists_quantify x p' ---> AC.[□↦ex , p]
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
IH1: Γ
⊢i AC.[□↦ex , p] $ p0 --->
   exists_quantify x p' $ p0
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed (exists_quantify x p')
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed (exists_quantify x (p' $ p0))
H: Γ ⊢i AC.[□↦ex , p] ---> exists_quantify x p'
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
evar_is_fresh_in x p0 eapply evar_is_fresh_in_app_r.
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC.[□↦p] $ p0)
Hwf: well_formed (ex , p) = true
p': Pattern
Heqp': p' = AC.[□↦p^{evar:0↦x}]
IH2: Γ ⊢i exists_quantify x p' ---> AC.[□↦ex , p]
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
IH1: Γ
⊢i AC.[□↦ex , p] $ p0 --->
   exists_quantify x p' $ p0
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed (exists_quantify x p')
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed (exists_quantify x (p' $ p0))
H: Γ ⊢i AC.[□↦ex , p] ---> exists_quantify x p'
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
evar_is_fresh_in x (?ϕ₁ $ p0) apply Hx. }
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC.[□↦p] $ p0)
Hwf: well_formed (ex , p) = true
p': Pattern
Heqp': p' = AC.[□↦p^{evar:0↦x}]
IH2: Γ ⊢i exists_quantify x p' ---> AC.[□↦ex , p]
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
IH1: Γ
⊢i AC.[□↦ex , p] $ p0 --->
   exists_quantify x p' $ p0
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed (exists_quantify x p')
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed (exists_quantify x (p' $ p0))
H: Γ ⊢i AC.[□↦ex , p] ---> exists_quantify x p'
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Γ
⊢i (ex , p'^{{evar:x↦0}}) $ p0 --->
   (ex , p'^{{evar:x↦0}} $ p0)
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
      useBasicReasoning.
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC.[□↦p] $ p0)
Hwf: well_formed (ex , p) = true
p': Pattern
Heqp': p' = AC.[□↦p^{evar:0↦x}]
IH2: Γ ⊢i exists_quantify x p' ---> AC.[□↦ex , p]
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
IH1: Γ
⊢i AC.[□↦ex , p] $ p0 --->
   exists_quantify x p' $ p0
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed (exists_quantify x p')
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed (exists_quantify x (p' $ p0))
H: Γ ⊢i AC.[□↦ex , p] ---> exists_quantify x p'
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Γ
⊢i (ex , p'^{{evar:x↦0}}) $ p0 --->
   (ex , p'^{{evar:x↦0}} $ p0) using BasicReasoning
      apply Prop_ex_left.
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC.[□↦p] $ p0)
Hwf: well_formed (ex , p) = true
p': Pattern
Heqp': p' = AC.[□↦p^{evar:0↦x}]
IH2: Γ ⊢i exists_quantify x p' ---> AC.[□↦ex , p]
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
IH1: Γ
⊢i AC.[□↦ex , p] $ p0 --->
   exists_quantify x p' $ p0
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed (exists_quantify x p')
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed (exists_quantify x (p' $ p0))
H: Γ ⊢i AC.[□↦ex , p] ---> exists_quantify x p'
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
well_formed (ex , p'^{{evar:x↦0}})
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC.[□↦p] $ p0)
Hwf: well_formed (ex , p) = true
p': Pattern
Heqp': p' = AC.[□↦p^{evar:0↦x}]
IH2: Γ ⊢i exists_quantify x p' ---> AC.[□↦ex , p]
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
IH1: Γ
⊢i AC.[□↦ex , p] $ p0 --->
   exists_quantify x p' $ p0
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed (exists_quantify x p')
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed (exists_quantify x (p' $ p0))
H: Γ ⊢i AC.[□↦ex , p] ---> exists_quantify x p'
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
well_formed p0 wf_auto2.
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC.[□↦p] $ p0)
Hwf: well_formed (ex , p) = true
p': Pattern
Heqp': p' = AC.[□↦p^{evar:0↦x}]
IH2: Γ ⊢i exists_quantify x p' ---> AC.[□↦ex , p]
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
IH1: Γ
⊢i AC.[□↦ex , p] $ p0 --->
   exists_quantify x p' $ p0
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed (exists_quantify x p')
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed (exists_quantify x (p' $ p0))
H: Γ ⊢i AC.[□↦ex , p] ---> exists_quantify x p'
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
well_formed p0 wf_auto2.
    +
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC.[□↦p] $ p0)
Hwf: well_formed (ex , p) = true
IH1: Γ ⊢i AC.[□↦ex , p] ---> exists_quantify x AC.[□↦p^{evar:0↦x}]
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
IH2: Γ ⊢i exists_quantify x AC.[□↦p^{evar:0↦x}] ---> AC.[□↦ex , p]
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed
  (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed
  (exists_quantify x
     (AC.[□↦p^{evar:0↦x}] $ p0))
Γ
⊢i exists_quantify x (AC.[□↦p^{evar:0↦x}] $ p0) --->
   AC.[□↦ex , p] $ p0
using (ExGen := {[x]}, SVSubst := ∅, KT := false) clear IH1.
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC.[□↦p] $ p0)
Hwf: well_formed (ex , p) = true
IH2: Γ ⊢i exists_quantify x AC.[□↦p^{evar:0↦x}] ---> AC.[□↦ex , p]
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed
  (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed
  (exists_quantify x
     (AC.[□↦p^{evar:0↦x}] $ p0))
Γ
⊢i exists_quantify x (AC.[□↦p^{evar:0↦x}] $ p0) --->
   AC.[□↦ex , p] $ p0
using (ExGen := {[x]}, SVSubst := ∅, KT := false)

      change constraint in IH2.
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC.[□↦p] $ p0)
Hwf: well_formed (ex , p) = true
IH2: Γ ⊢i exists_quantify x AC.[□↦p^{evar:0↦x}] ---> AC.[□↦ex , p]
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed
  (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed
  (exists_quantify x
     (AC.[□↦p^{evar:0↦x}] $ p0))
Γ
⊢i exists_quantify x (AC.[□↦p^{evar:0↦x}] $ p0) --->
   AC.[□↦ex , p] $ p0
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
      apply Framing_left with (ψ := p0) in IH2; auto.
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC.[□↦p] $ p0)
Hwf: well_formed (ex , p) = true
IH2: Γ ⊢i exists_quantify x AC.[□↦p^{evar:0↦x}] $ p0 ---> AC.[□↦ex , p] $ p0
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed
  (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed
  (exists_quantify x
     (AC.[□↦p^{evar:0↦x}] $ p0))
Γ
⊢i exists_quantify x (AC.[□↦p^{evar:0↦x}] $ p0) --->
   AC.[□↦ex , p] $ p0
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC.[□↦p] $ p0)
Hwf: well_formed (ex , p) = true
IH2: Γ
⊢i exists_quantify x AC.[□↦p^{evar:0↦x}] --->
   AC.[□↦ex , p]
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed
  (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed
  (exists_quantify x
     (AC.[□↦p^{evar:0↦x}] $ p0))
ProofInfoLe (ExGen := ∅, SVSubst := ∅, KT := false)
  (ExGen := {[x]}, SVSubst := ∅, KT := false)
      2: {
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC.[□↦p] $ p0)
Hwf: well_formed (ex , p) = true
IH2: Γ ⊢i exists_quantify x AC.[□↦p^{evar:0↦x}] ---> AC.[□↦ex , p]
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed
  (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed
  (exists_quantify x
     (AC.[□↦p^{evar:0↦x}] $ p0))
ProofInfoLe (ExGen := ∅, SVSubst := ∅, KT := false)
  (ExGen := {[x]}, SVSubst := ∅, KT := false) try_solve_pile. }
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC.[□↦p] $ p0)
Hwf: well_formed (ex , p) = true
IH2: Γ ⊢i exists_quantify x AC.[□↦p^{evar:0↦x}] $ p0 ---> AC.[□↦ex , p] $ p0
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed
  (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed
  (exists_quantify x
     (AC.[□↦p^{evar:0↦x}] $ p0))
Γ
⊢i exists_quantify x (AC.[□↦p^{evar:0↦x}] $ p0) --->
   AC.[□↦ex , p] $ p0
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
      eapply syllogism_meta.
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC.[□↦p] $ p0)
Hwf: well_formed (ex , p) = true
IH2: Γ ⊢i exists_quantify x AC.[□↦p^{evar:0↦x}] $ p0 ---> AC.[□↦ex , p] $ p0
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed
  (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed
  (exists_quantify x
     (AC.[□↦p^{evar:0↦x}] $ p0))
well_formed
  (exists_quantify x (AC.[□↦p^{evar:0↦x}] $ p0))
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC.[□↦p] $ p0)
Hwf: well_formed (ex , p) = true
IH2: Γ
⊢i exists_quantify x AC.[□↦p^{evar:0↦x}] $ p0 --->
   AC.[□↦ex , p] $ p0
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed
  (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed
  (exists_quantify x
     (AC.[□↦p^{evar:0↦x}] $ p0))
well_formed ?B
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC.[□↦p] $ p0)
Hwf: well_formed (ex , p) = true
IH2: Γ
⊢i exists_quantify x AC.[□↦p^{evar:0↦x}] $ p0 --->
   AC.[□↦ex , p] $ p0
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed
  (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed
  (exists_quantify x
     (AC.[□↦p^{evar:0↦x}] $ p0))
well_formed (AC.[□↦ex , p] $ p0)
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC.[□↦p] $ p0)
Hwf: well_formed (ex , p) = true
IH2: Γ
⊢i exists_quantify x AC.[□↦p^{evar:0↦x}] $ p0 --->
   AC.[□↦ex , p] $ p0
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed
  (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed
  (exists_quantify x
     (AC.[□↦p^{evar:0↦x}] $ p0))
Γ
⊢i exists_quantify x (AC.[□↦p^{evar:0↦x}] $ p0) --->
   ?B
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC.[□↦p] $ p0)
Hwf: well_formed (ex , p) = true
IH2: Γ
⊢i exists_quantify x AC.[□↦p^{evar:0↦x}] $ p0 --->
   AC.[□↦ex , p] $ p0
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed
  (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed
  (exists_quantify x
     (AC.[□↦p^{evar:0↦x}] $ p0))
Γ ⊢i ?B ---> AC.[□↦ex , p] $ p0
using (ExGen := {[x]}, SVSubst := ∅, KT := false) 5: eapply IH2.
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC.[□↦p] $ p0)
Hwf: well_formed (ex , p) = true
IH2: Γ ⊢i exists_quantify x AC.[□↦p^{evar:0↦x}] $ p0 ---> AC.[□↦ex , p] $ p0
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed
  (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed
  (exists_quantify x
     (AC.[□↦p^{evar:0↦x}] $ p0))
well_formed
  (exists_quantify x (AC.[□↦p^{evar:0↦x}] $ p0))
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC.[□↦p] $ p0)
Hwf: well_formed (ex , p) = true
IH2: Γ
⊢i exists_quantify x AC.[□↦p^{evar:0↦x}] $ p0 --->
   AC.[□↦ex , p] $ p0
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed
  (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed
  (exists_quantify x
     (AC.[□↦p^{evar:0↦x}] $ p0))
well_formed
  (exists_quantify x AC.[□↦p^{evar:0↦x}] $ p0)
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC.[□↦p] $ p0)
Hwf: well_formed (ex , p) = true
IH2: Γ
⊢i exists_quantify x AC.[□↦p^{evar:0↦x}] $ p0 --->
   AC.[□↦ex , p] $ p0
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed
  (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed
  (exists_quantify x
     (AC.[□↦p^{evar:0↦x}] $ p0))
well_formed (AC.[□↦ex , p] $ p0)
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC.[□↦p] $ p0)
Hwf: well_formed (ex , p) = true
IH2: Γ
⊢i exists_quantify x AC.[□↦p^{evar:0↦x}] $ p0 --->
   AC.[□↦ex , p] $ p0
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed
  (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed
  (exists_quantify x
     (AC.[□↦p^{evar:0↦x}] $ p0))
Γ
⊢i exists_quantify x (AC.[□↦p^{evar:0↦x}] $ p0) --->
   exists_quantify x AC.[□↦p^{evar:0↦x}] $ p0
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
      1-3: wf_auto2.
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC.[□↦p] $ p0)
Hwf: well_formed (ex , p) = true
IH2: Γ ⊢i exists_quantify x AC.[□↦p^{evar:0↦x}] $ p0 ---> AC.[□↦ex , p] $ p0
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed
  (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed
  (exists_quantify x
     (AC.[□↦p^{evar:0↦x}] $ p0))
Γ
⊢i exists_quantify x (AC.[□↦p^{evar:0↦x}] $ p0) --->
   exists_quantify x AC.[□↦p^{evar:0↦x}] $ p0
using (ExGen := {[x]}, SVSubst := ∅, KT := false)

      apply Ex_gen; auto.
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC.[□↦p] $ p0)
Hwf: well_formed (ex , p) = true
IH2: Γ ⊢i exists_quantify x AC.[□↦p^{evar:0↦x}] $ p0 ---> AC.[□↦ex , p] $ p0
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed
  (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed
  (exists_quantify x
     (AC.[□↦p^{evar:0↦x}] $ p0))
ProofInfoLe
  (ExGen := {[x]}, SVSubst := ∅, KT := false)
  (ExGen := {[x]}, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC.[□↦p] $ p0)
Hwf: well_formed (ex , p) = true
IH2: Γ
⊢i exists_quantify x AC.[□↦p^{evar:0↦x}] $ p0 --->
   AC.[□↦ex , p] $ p0
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed
  (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed
  (exists_quantify x
     (AC.[□↦p^{evar:0↦x}] $ p0))
x
∉ free_evars
    (exists_quantify x AC.[□↦p^{evar:0↦x}] $ p0)
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC.[□↦p] $ p0)
Hwf: well_formed (ex , p) = true
IH2: Γ
⊢i exists_quantify x AC.[□↦p^{evar:0↦x}] $ p0 --->
   AC.[□↦ex , p] $ p0
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed
  (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed
  (exists_quantify x
     (AC.[□↦p^{evar:0↦x}] $ p0))
Γ
⊢i AC.[□↦p^{evar:0↦x}] $ p0 --->
   exists_quantify x AC.[□↦p^{evar:0↦x}] $ p0
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
      {
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC.[□↦p] $ p0)
Hwf: well_formed (ex , p) = true
IH2: Γ ⊢i exists_quantify x AC.[□↦p^{evar:0↦x}] $ p0 ---> AC.[□↦ex , p] $ p0
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed
  (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed
  (exists_quantify x
     (AC.[□↦p^{evar:0↦x}] $ p0))
ProofInfoLe
  (ExGen := {[x]}, SVSubst := ∅, KT := false)
  (ExGen := {[x]}, SVSubst := ∅, KT := false) try_solve_pile. }
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC.[□↦p] $ p0)
Hwf: well_formed (ex , p) = true
IH2: Γ ⊢i exists_quantify x AC.[□↦p^{evar:0↦x}] $ p0 ---> AC.[□↦ex , p] $ p0
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed
  (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed
  (exists_quantify x
     (AC.[□↦p^{evar:0↦x}] $ p0))
x
∉ free_evars
    (exists_quantify x AC.[□↦p^{evar:0↦x}] $ p0)
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC.[□↦p] $ p0)
Hwf: well_formed (ex , p) = true
IH2: Γ
⊢i exists_quantify x AC.[□↦p^{evar:0↦x}] $ p0 --->
   AC.[□↦ex , p] $ p0
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed
  (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed
  (exists_quantify x
     (AC.[□↦p^{evar:0↦x}] $ p0))
Γ
⊢i AC.[□↦p^{evar:0↦x}] $ p0 --->
   exists_quantify x AC.[□↦p^{evar:0↦x}] $ p0
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
      1: {
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC.[□↦p] $ p0)
Hwf: well_formed (ex , p) = true
IH2: Γ ⊢i exists_quantify x AC.[□↦p^{evar:0↦x}] $ p0 ---> AC.[□↦ex , p] $ p0
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed
  (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed
  (exists_quantify x
     (AC.[□↦p^{evar:0↦x}] $ p0))
x
∉ free_evars
    (exists_quantify x AC.[□↦p^{evar:0↦x}] $ p0)
        unfold exists_quantify.
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC.[□↦p] $ p0)
Hwf: well_formed (ex , p) = true
IH2: Γ ⊢i exists_quantify x AC.[□↦p^{evar:0↦x}] $ p0 ---> AC.[□↦ex , p] $ p0
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed
  (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed
  (exists_quantify x
     (AC.[□↦p^{evar:0↦x}] $ p0))
x
∉ free_evars
    ((ex , AC.[□↦p^{evar:0↦x}]^{{evar:x↦0}}) $ p0)
        simpl.
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC.[□↦p] $ p0)
Hwf: well_formed (ex , p) = true
IH2: Γ ⊢i exists_quantify x AC.[□↦p^{evar:0↦x}] $ p0 ---> AC.[□↦ex , p] $ p0
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed
  (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed
  (exists_quantify x
     (AC.[□↦p^{evar:0↦x}] $ p0))
x
∉ free_evars AC.[□↦p^{evar:0↦x}]^{{evar:x↦0}}
  ∪ free_evars p0
        rewrite free_evars_evar_quantify.
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC.[□↦p] $ p0)
Hwf: well_formed (ex , p) = true
IH2: Γ ⊢i exists_quantify x AC.[□↦p^{evar:0↦x}] $ p0 ---> AC.[□↦ex , p] $ p0
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed
  (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed
  (exists_quantify x
     (AC.[□↦p^{evar:0↦x}] $ p0))
x
∉ free_evars AC.[□↦p^{evar:0↦x}] ∖ {[x]}
  ∪ free_evars p0
        unfold evar_is_fresh_in in Hx.
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: x ∉ free_evars (AC.[□↦p] $ p0)
Hwf: well_formed (ex , p) = true
IH2: Γ ⊢i exists_quantify x AC.[□↦p^{evar:0↦x}] $ p0 ---> AC.[□↦ex , p] $ p0
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed
  (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed
  (exists_quantify x
     (AC.[□↦p^{evar:0↦x}] $ p0))
x
∉ free_evars AC.[□↦p^{evar:0↦x}] ∖ {[x]}
  ∪ free_evars p0 simpl in Hx.
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: x ∉ free_evars AC.[□↦p] ∪ free_evars p0
Hwf: well_formed (ex , p) = true
IH2: Γ ⊢i exists_quantify x AC.[□↦p^{evar:0↦x}] $ p0 ---> AC.[□↦ex , p] $ p0
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed
  (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed
  (exists_quantify x
     (AC.[□↦p^{evar:0↦x}] $ p0))
x
∉ free_evars AC.[□↦p^{evar:0↦x}] ∖ {[x]}
  ∪ free_evars p0 clear -Hx.
Σ: Signature
AC: Application_context
p0, p: Pattern
x: evar
Hx: x ∉ free_evars AC.[□↦p] ∪ free_evars p0
x
∉ free_evars AC.[□↦p^{evar:0↦x}] ∖ {[x]}
  ∪ free_evars p0
        set_solver.
      }
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC.[□↦p] $ p0)
Hwf: well_formed (ex , p) = true
IH2: Γ ⊢i exists_quantify x AC.[□↦p^{evar:0↦x}] $ p0 ---> AC.[□↦ex , p] $ p0
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed
  (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed
  (exists_quantify x
     (AC.[□↦p^{evar:0↦x}] $ p0))
Γ
⊢i AC.[□↦p^{evar:0↦x}] $ p0 --->
   exists_quantify x AC.[□↦p^{evar:0↦x}] $ p0
using (ExGen := {[x]}, SVSubst := ∅, KT := false)

      (* TODO have some nice implicit parameters *)
      gapply (Framing_left _ _ _ _ _ Prf).
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC.[□↦p] $ p0)
Hwf: well_formed (ex , p) = true
IH2: Γ ⊢i exists_quantify x AC.[□↦p^{evar:0↦x}] $ p0 ---> AC.[□↦ex , p] $ p0
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed
  (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed
  (exists_quantify x
     (AC.[□↦p^{evar:0↦x}] $ p0))
ProofInfoLe ?i'
  (ExGen := {[x]}, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC.[□↦p] $ p0)
Hwf: well_formed (ex , p) = true
IH2: Γ
⊢i exists_quantify x AC.[□↦p^{evar:0↦x}] $ p0 --->
   AC.[□↦ex , p] $ p0
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed
  (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed
  (exists_quantify x
     (AC.[□↦p^{evar:0↦x}] $ p0))
Γ
⊢i AC.[□↦p^{evar:0↦x}] --->
   exists_quantify x AC.[□↦p^{evar:0↦x}] using 
?i'
      apply pile_refl.
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC.[□↦p] $ p0)
Hwf: well_formed (ex , p) = true
IH2: Γ ⊢i exists_quantify x AC.[□↦p^{evar:0↦x}] $ p0 ---> AC.[□↦ex , p] $ p0
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed
  (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed
  (exists_quantify x
     (AC.[□↦p^{evar:0↦x}] $ p0))
Γ
⊢i AC.[□↦p^{evar:0↦x}] --->
   exists_quantify x AC.[□↦p^{evar:0↦x}]
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
      Unshelve.
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC.[□↦p] $ p0)
Hwf: well_formed (ex , p) = true
IH2: Γ ⊢i exists_quantify x AC.[□↦p^{evar:0↦x}] $ p0 ---> AC.[□↦ex , p] $ p0
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed
  (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed
  (exists_quantify x
     (AC.[□↦p^{evar:0↦x}] $ p0))
Γ
⊢i AC.[□↦p^{evar:0↦x}] --->
   exists_quantify x AC.[□↦p^{evar:0↦x}]
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC.[□↦p] $ p0)
Hwf: well_formed (ex , p) = true
IH2: Γ
⊢i exists_quantify x AC.[□↦p^{evar:0↦x}] $ p0 --->
   AC.[□↦ex , p] $ p0
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed
  (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed
  (exists_quantify x
     (AC.[□↦p^{evar:0↦x}] $ p0))
ProofInfoLe (ExGen := ∅, SVSubst := ∅, KT := false)
  (ExGen := {[x]}, SVSubst := ∅, KT := false) 2: {
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC.[□↦p] $ p0)
Hwf: well_formed (ex , p) = true
IH2: Γ ⊢i exists_quantify x AC.[□↦p^{evar:0↦x}] $ p0 ---> AC.[□↦ex , p] $ p0
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed
  (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed
  (exists_quantify x
     (AC.[□↦p^{evar:0↦x}] $ p0))
ProofInfoLe (ExGen := ∅, SVSubst := ∅, KT := false)
  (ExGen := {[x]}, SVSubst := ∅, KT := false) try_solve_pile. }
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC.[□↦p] $ p0)
Hwf: well_formed (ex , p) = true
IH2: Γ ⊢i exists_quantify x AC.[□↦p^{evar:0↦x}] $ p0 ---> AC.[□↦ex , p] $ p0
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed
  (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed
  (exists_quantify x
     (AC.[□↦p^{evar:0↦x}] $ p0))
Γ
⊢i AC.[□↦p^{evar:0↦x}] --->
   exists_quantify x AC.[□↦p^{evar:0↦x}]
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
      unfold evar_open.
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC.[□↦p] $ p0)
Hwf: well_formed (ex , p) = true
IH2: Γ ⊢i exists_quantify x AC.[□↦p^{evar:0↦x}] $ p0 ---> AC.[□↦ex , p] $ p0
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed
  (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed
  (exists_quantify x
     (AC.[□↦p^{evar:0↦x}] $ p0))
Γ
⊢i AC.[□↦p^[evar:0↦patt_free_evar x]] --->
   exists_quantify x
     AC.[□↦p^[evar:0↦patt_free_evar x]]
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
      rewrite subst_ctx_bevar_subst.
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC.[□↦p] $ p0)
Hwf: well_formed (ex , p) = true
IH2: Γ ⊢i exists_quantify x AC.[□↦p^{evar:0↦x}] $ p0 ---> AC.[□↦ex , p] $ p0
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed
  (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed
  (exists_quantify x
     (AC.[□↦p^{evar:0↦x}] $ p0))
Γ
⊢i AC.[□↦p]^[evar:0↦patt_free_evar x] --->
   exists_quantify x
     AC.[□↦p]^[evar:0↦patt_free_evar x]
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
      unfold exists_quantify.
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC.[□↦p] $ p0)
Hwf: well_formed (ex , p) = true
IH2: Γ ⊢i exists_quantify x AC.[□↦p^{evar:0↦x}] $ p0 ---> AC.[□↦ex , p] $ p0
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed
  (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed
  (exists_quantify x
     (AC.[□↦p^{evar:0↦x}] $ p0))
Γ
⊢i AC.[□↦p]^[evar:0↦patt_free_evar x] --->
   (ex ,
    AC.[□↦p]^[evar:0↦patt_free_evar x]^{{evar:x↦0}})
using (ExGen := {[x]}, SVSubst := ∅, KT := false) simpl.
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC.[□↦p] $ p0)
Hwf: well_formed (ex , p) = true
IH2: Γ ⊢i exists_quantify x AC.[□↦p^{evar:0↦x}] $ p0 ---> AC.[□↦ex , p] $ p0
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed
  (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed
  (exists_quantify x
     (AC.[□↦p^{evar:0↦x}] $ p0))
Γ
⊢i AC.[□↦p]^[evar:0↦patt_free_evar x] --->
   (ex ,
    AC.[□↦p]^[evar:0↦patt_free_evar x]^{{evar:x↦0}})
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
      fold ((subst_ctx AC p)^{evar: 0 ↦ x}).
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC.[□↦p] $ p0)
Hwf: well_formed (ex , p) = true
IH2: Γ ⊢i exists_quantify x AC.[□↦p^{evar:0↦x}] $ p0 ---> AC.[□↦ex , p] $ p0
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed
  (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed
  (exists_quantify x
     (AC.[□↦p^{evar:0↦x}] $ p0))
Γ
⊢i AC.[□↦p]^{evar:0↦x} --->
   (ex , AC.[□↦p]^{evar:0↦x}^{{evar:x↦0}})
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
      rewrite -> evar_quantify_evar_open; auto.
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC.[□↦p] $ p0)
Hwf: well_formed (ex , p) = true
IH2: Γ ⊢i exists_quantify x AC.[□↦p^{evar:0↦x}] $ p0 ---> AC.[□↦ex , p] $ p0
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed
  (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed
  (exists_quantify x
     (AC.[□↦p^{evar:0↦x}] $ p0))
Γ ⊢i AC.[□↦p]^{evar:0↦x} ---> (ex , AC.[□↦p])
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC.[□↦p] $ p0)
Hwf: well_formed (ex , p) = true
IH2: Γ
⊢i exists_quantify x AC.[□↦p^{evar:0↦x}] $ p0 --->
   AC.[□↦ex , p] $ p0
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed
  (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed
  (exists_quantify x
     (AC.[□↦p^{evar:0↦x}] $ p0))
well_formed_closed_ex_aux AC.[□↦p] 1
      2: now do 2 apply andb_true_iff in Hwfex as [_ Hwfex].
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC.[□↦p] $ p0)
Hwf: well_formed (ex , p) = true
IH2: Γ ⊢i exists_quantify x AC.[□↦p^{evar:0↦x}] $ p0 ---> AC.[□↦ex , p] $ p0
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed
  (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed
  (exists_quantify x
     (AC.[□↦p^{evar:0↦x}] $ p0))
Γ ⊢i AC.[□↦p]^{evar:0↦x} ---> (ex , AC.[□↦p])
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
      useBasicReasoning.
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC.[□↦p] $ p0)
Hwf: well_formed (ex , p) = true
IH2: Γ ⊢i exists_quantify x AC.[□↦p^{evar:0↦x}] $ p0 ---> AC.[□↦ex , p] $ p0
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed
  (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed
  (exists_quantify x
     (AC.[□↦p^{evar:0↦x}] $ p0))
Γ ⊢i AC.[□↦p]^{evar:0↦x} ---> (ex , AC.[□↦p])
using BasicReasoning
      apply Ex_quan; auto.
  -
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (p0 $ᵣ AC).[□↦p]
Hwf: well_formed (ex , p) = true
IHAC: evar_is_fresh_in x AC.[□↦p]
→ Γ
  ⊢i AC.[□↦ex , p] <--->
     exists_quantify x AC.[□↦p^{evar:0↦x}]
  using (ExGen := {[x]}, SVSubst := ∅,
         KT := false)
Γ
⊢i p0 $ AC.[□↦ex , p] <--->
   exists_quantify x (p0 $ AC.[□↦p^{evar:0↦x}])
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
    assert (Hwfex: well_formed (ex , subst_ctx AC p)).
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (p0 $ᵣ AC).[□↦p]
Hwf: well_formed (ex , p) = true
IHAC: evar_is_fresh_in x AC.[□↦p]
→ Γ
  ⊢i AC.[□↦ex , p] <--->
     exists_quantify x AC.[□↦p^{evar:0↦x}]
  using (ExGen := {[x]}, SVSubst := ∅,
         KT := false)
well_formed (ex , AC.[□↦p])
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (p0 $ᵣ AC).[□↦p]
Hwf: well_formed (ex , p) = true
IHAC: evar_is_fresh_in x AC.[□↦p]
→ Γ
  ⊢i AC.[□↦ex , p] <--->
     exists_quantify x AC.[□↦p^{evar:0↦x}]
  using (ExGen := {[x]}, SVSubst := ∅,
         KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Γ
⊢i p0 $ AC.[□↦ex , p] <--->
   exists_quantify x (p0 $ AC.[□↦p^{evar:0↦x}])
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
    {
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (p0 $ᵣ AC).[□↦p]
Hwf: well_formed (ex , p) = true
IHAC: evar_is_fresh_in x AC.[□↦p]
→ Γ
  ⊢i AC.[□↦ex , p] <--->
     exists_quantify x AC.[□↦p^{evar:0↦x}]
  using (ExGen := {[x]}, SVSubst := ∅,
         KT := false)
well_formed (ex , AC.[□↦p]) clear Hx.
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p: Pattern
x: evar
Hwf: well_formed (ex , p) = true
IHAC: evar_is_fresh_in x AC.[□↦p]
→ Γ
  ⊢i AC.[□↦ex , p] <--->
     exists_quantify x AC.[□↦p^{evar:0↦x}]
  using (ExGen := {[x]}, SVSubst := ∅,
         KT := false)
well_formed (ex , AC.[□↦p]) wf_auto2. }
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (p0 $ᵣ AC).[□↦p]
Hwf: well_formed (ex , p) = true
IHAC: evar_is_fresh_in x AC.[□↦p]
→ Γ
  ⊢i AC.[□↦ex , p] <--->
     exists_quantify x AC.[□↦p^{evar:0↦x}]
  using (ExGen := {[x]}, SVSubst := ∅,
         KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Γ
⊢i p0 $ AC.[□↦ex , p] <--->
   exists_quantify x (p0 $ AC.[□↦p^{evar:0↦x}])
using (ExGen := {[x]}, SVSubst := ∅, KT := false)

    assert(Hxfr1: evar_is_fresh_in x (subst_ctx AC p)).
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (p0 $ᵣ AC).[□↦p]
Hwf: well_formed (ex , p) = true
IHAC: evar_is_fresh_in x AC.[□↦p]
→ Γ
  ⊢i AC.[□↦ex , p] <--->
     exists_quantify x AC.[□↦p^{evar:0↦x}]
  using (ExGen := {[x]}, SVSubst := ∅,
         KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
evar_is_fresh_in x AC.[□↦p]
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (p0 $ᵣ AC).[□↦p]
Hwf: well_formed (ex , p) = true
IHAC: evar_is_fresh_in x AC.[□↦p]
→ Γ
  ⊢i AC.[□↦ex , p] <--->
     exists_quantify x AC.[□↦p^{evar:0↦x}]
  using (ExGen := {[x]}, SVSubst := ∅,
         KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Γ
⊢i p0 $ AC.[□↦ex , p] <--->
   exists_quantify x (p0 $ AC.[□↦p^{evar:0↦x}])
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
    {
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (p0 $ᵣ AC).[□↦p]
Hwf: well_formed (ex , p) = true
IHAC: evar_is_fresh_in x AC.[□↦p]
→ Γ
  ⊢i AC.[□↦ex , p] <--->
     exists_quantify x AC.[□↦p^{evar:0↦x}]
  using (ExGen := {[x]}, SVSubst := ∅,
         KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
evar_is_fresh_in x AC.[□↦p] simpl in Hx.
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (p0 $ AC.[□↦p])
Hwf: well_formed (ex , p) = true
IHAC: evar_is_fresh_in x AC.[□↦p]
→ Γ
  ⊢i AC.[□↦ex , p] <--->
     exists_quantify x AC.[□↦p^{evar:0↦x}]
  using (ExGen := {[x]}, SVSubst := ∅,
         KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
evar_is_fresh_in x AC.[□↦p]
      eapply evar_is_fresh_in_richer.
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (p0 $ AC.[□↦p])
Hwf: well_formed (ex , p) = true
IHAC: evar_is_fresh_in x AC.[□↦p]
→ Γ
  ⊢i AC.[□↦ex , p] <--->
     exists_quantify x AC.[□↦p^{evar:0↦x}]
  using (ExGen := {[x]}, SVSubst := ∅,
         KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
free_evars AC.[□↦p] ⊆ free_evars ?ϕ₂
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (p0 $ AC.[□↦p])
Hwf: well_formed (ex , p) = true
IHAC: evar_is_fresh_in x AC.[□↦p]
→ Γ
  ⊢i AC.[□↦ex , p] <--->
     exists_quantify x AC.[□↦p^{evar:0↦x}]
  using (ExGen := {[x]}, SVSubst := ∅,
         KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
evar_is_fresh_in x ?ϕ₂
      2: {
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (p0 $ AC.[□↦p])
Hwf: well_formed (ex , p) = true
IHAC: evar_is_fresh_in x AC.[□↦p]
→ Γ
  ⊢i AC.[□↦ex , p] <--->
     exists_quantify x AC.[□↦p^{evar:0↦x}]
  using (ExGen := {[x]}, SVSubst := ∅,
         KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
evar_is_fresh_in x ?ϕ₂ apply Hx. }
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (p0 $ AC.[□↦p])
Hwf: well_formed (ex , p) = true
IHAC: evar_is_fresh_in x AC.[□↦p]
→ Γ
  ⊢i AC.[□↦ex , p] <--->
     exists_quantify x AC.[□↦p^{evar:0↦x}]
  using (ExGen := {[x]}, SVSubst := ∅,
         KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
free_evars AC.[□↦p] ⊆ free_evars (p0 $ AC.[□↦p])
      solve_free_evars_inclusion 5.
    }
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (p0 $ᵣ AC).[□↦p]
Hwf: well_formed (ex , p) = true
IHAC: evar_is_fresh_in x AC.[□↦p]
→ Γ
  ⊢i AC.[□↦ex , p] <--->
     exists_quantify x AC.[□↦p^{evar:0↦x}]
  using (ExGen := {[x]}, SVSubst := ∅,
         KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Γ
⊢i p0 $ AC.[□↦ex , p] <--->
   exists_quantify x (p0 $ AC.[□↦p^{evar:0↦x}])
using (ExGen := {[x]}, SVSubst := ∅, KT := false)

    simpl in Hx.
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (p0 $ AC.[□↦p])
Hwf: well_formed (ex , p) = true
IHAC: evar_is_fresh_in x AC.[□↦p]
→ Γ
  ⊢i AC.[□↦ex , p] <--->
     exists_quantify x AC.[□↦p^{evar:0↦x}]
  using (ExGen := {[x]}, SVSubst := ∅,
         KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Γ
⊢i p0 $ AC.[□↦ex , p] <--->
   exists_quantify x (p0 $ AC.[□↦p^{evar:0↦x}])
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
    pose proof (Hxfr1' := Hxfr1).
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (p0 $ AC.[□↦p])
Hwf: well_formed (ex , p) = true
IHAC: evar_is_fresh_in x AC.[□↦p]
→ Γ
  ⊢i AC.[□↦ex , p] <--->
     exists_quantify x AC.[□↦p^{evar:0↦x}]
  using (ExGen := {[x]}, SVSubst := ∅,
         KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1, Hxfr1': evar_is_fresh_in x AC.[□↦p]
Γ
⊢i p0 $ AC.[□↦ex , p] <--->
   exists_quantify x (p0 $ AC.[□↦p^{evar:0↦x}])
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
    rewrite -> evar_is_fresh_in_subst_ctx in Hxfr1'.
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (p0 $ AC.[□↦p])
Hwf: well_formed (ex , p) = true
IHAC: evar_is_fresh_in x AC.[□↦p]
→ Γ
  ⊢i AC.[□↦ex , p] <--->
     exists_quantify x AC.[□↦p^{evar:0↦x}]
  using (ExGen := {[x]}, SVSubst := ∅,
         KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfr1': evar_is_fresh_in x p ∧ x ∉ AC_free_evars AC
Γ
⊢i p0 $ AC.[□↦ex , p] <--->
   exists_quantify x (p0 $ AC.[□↦p^{evar:0↦x}])
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
    destruct Hxfr1' as [Hxfrp HxAC].
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (p0 $ AC.[□↦p])
Hwf: well_formed (ex , p) = true
IHAC: evar_is_fresh_in x AC.[□↦p]
→ Γ
  ⊢i AC.[□↦ex , p] <--->
     exists_quantify x AC.[□↦p^{evar:0↦x}]
  using (ExGen := {[x]}, SVSubst := ∅,
         KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Γ
⊢i p0 $ AC.[□↦ex , p] <--->
   exists_quantify x (p0 $ AC.[□↦p^{evar:0↦x}])
using (ExGen := {[x]}, SVSubst := ∅, KT := false)

    assert(Hwf': well_formed (exists_quantify x (subst_ctx AC (p^{evar: 0 ↦ x})))).
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (p0 $ AC.[□↦p])
Hwf: well_formed (ex , p) = true
IHAC: evar_is_fresh_in x AC.[□↦p]
→ Γ
  ⊢i AC.[□↦ex , p] <--->
     exists_quantify x AC.[□↦p^{evar:0↦x}]
  using (ExGen := {[x]}, SVSubst := ∅,
         KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
well_formed (exists_quantify x AC.[□↦p^{evar:0↦x}])
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (p0 $ AC.[□↦p])
Hwf: well_formed (ex , p) = true
IHAC: evar_is_fresh_in x AC.[□↦p]
→ Γ
  ⊢i AC.[□↦ex , p] <--->
     exists_quantify x AC.[□↦p^{evar:0↦x}]
  using (ExGen := {[x]}, SVSubst := ∅,
         KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed
  (exists_quantify x AC.[□↦p^{evar:0↦x}])
Γ
⊢i p0 $ AC.[□↦ex , p] <--->
   exists_quantify x (p0 $ AC.[□↦p^{evar:0↦x}])
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
    {
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (p0 $ AC.[□↦p])
Hwf: well_formed (ex , p) = true
IHAC: evar_is_fresh_in x AC.[□↦p]
→ Γ
  ⊢i AC.[□↦ex , p] <--->
     exists_quantify x AC.[□↦p^{evar:0↦x}]
  using (ExGen := {[x]}, SVSubst := ∅,
         KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
well_formed (exists_quantify x AC.[□↦p^{evar:0↦x}])
      unfold exists_quantify.
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (p0 $ AC.[□↦p])
Hwf: well_formed (ex , p) = true
IHAC: evar_is_fresh_in x AC.[□↦p]
→ Γ
  ⊢i AC.[□↦ex , p] <--->
     exists_quantify x AC.[□↦p^{evar:0↦x}]
  using (ExGen := {[x]}, SVSubst := ∅,
         KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
well_formed (ex , AC.[□↦p^{evar:0↦x}]^{{evar:x↦0}})
      clear -HxAC Hwf.
Σ: Signature
AC: Application_context
p: Pattern
x: evar
Hwf: well_formed (ex , p) = true
HxAC: x ∉ AC_free_evars AC
well_formed (ex , AC.[□↦p^{evar:0↦x}]^{{evar:x↦0}})
      apply wf_ex_eq_sctx_eo.
Σ: Signature
AC: Application_context
p: Pattern
x: evar
Hwf: well_formed (ex , p) = true
HxAC: x ∉ AC_free_evars AC
well_formed (ex , p) = true
      apply Hwf.
    }
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (p0 $ AC.[□↦p])
Hwf: well_formed (ex , p) = true
IHAC: evar_is_fresh_in x AC.[□↦p]
→ Γ
  ⊢i AC.[□↦ex , p] <--->
     exists_quantify x AC.[□↦p^{evar:0↦x}]
  using (ExGen := {[x]}, SVSubst := ∅,
         KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed
  (exists_quantify x AC.[□↦p^{evar:0↦x}])
Γ
⊢i p0 $ AC.[□↦ex , p] <--->
   exists_quantify x (p0 $ AC.[□↦p^{evar:0↦x}])
using (ExGen := {[x]}, SVSubst := ∅, KT := false)

    assert (Hwfeo: well_formed (p^{evar: 0 ↦ x})).
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (p0 $ AC.[□↦p])
Hwf: well_formed (ex , p) = true
IHAC: evar_is_fresh_in x AC.[□↦p]
→ Γ
  ⊢i AC.[□↦ex , p] <--->
     exists_quantify x AC.[□↦p^{evar:0↦x}]
  using (ExGen := {[x]}, SVSubst := ∅,
         KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed
  (exists_quantify x AC.[□↦p^{evar:0↦x}])
well_formed p^{evar:0↦x}
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (p0 $ AC.[□↦p])
Hwf: well_formed (ex , p) = true
IHAC: evar_is_fresh_in x AC.[□↦p]
→ Γ
  ⊢i AC.[□↦ex , p] <--->
     exists_quantify x AC.[□↦p^{evar:0↦x}]
  using (ExGen := {[x]}, SVSubst := ∅,
         KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed
  (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Γ
⊢i p0 $ AC.[□↦ex , p] <--->
   exists_quantify x (p0 $ AC.[□↦p^{evar:0↦x}])
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
    {
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (p0 $ AC.[□↦p])
Hwf: well_formed (ex , p) = true
IHAC: evar_is_fresh_in x AC.[□↦p]
→ Γ
  ⊢i AC.[□↦ex , p] <--->
     exists_quantify x AC.[□↦p^{evar:0↦x}]
  using (ExGen := {[x]}, SVSubst := ∅,
         KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed
  (exists_quantify x AC.[□↦p^{evar:0↦x}])
well_formed p^{evar:0↦x}
      wf_auto2.
    }
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (p0 $ AC.[□↦p])
Hwf: well_formed (ex , p) = true
IHAC: evar_is_fresh_in x AC.[□↦p]
→ Γ
  ⊢i AC.[□↦ex , p] <--->
     exists_quantify x AC.[□↦p^{evar:0↦x}]
  using (ExGen := {[x]}, SVSubst := ∅,
         KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed
  (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Γ
⊢i p0 $ AC.[□↦ex , p] <--->
   exists_quantify x (p0 $ AC.[□↦p^{evar:0↦x}])
using (ExGen := {[x]}, SVSubst := ∅, KT := false)

    (* TODO automate this. The problem is that [well_formed_app] and others do not have [= true];
       that is why [auto] does not work. But [auto] is not suitable for this anyway.
       A better way would be to create some `simpl_well_formed` tuple, that might use the type class
       mechanism for extension...
     *)
    assert(Hwf'p0: well_formed (exists_quantify x (p0 $ subst_ctx AC (p^{evar: 0 ↦ x})))).
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (p0 $ AC.[□↦p])
Hwf: well_formed (ex , p) = true
IHAC: evar_is_fresh_in x AC.[□↦p]
→ Γ
  ⊢i AC.[□↦ex , p] <--->
     exists_quantify x AC.[□↦p^{evar:0↦x}]
  using (ExGen := {[x]}, SVSubst := ∅,
         KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed
  (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
well_formed
  (exists_quantify x (p0 $ AC.[□↦p^{evar:0↦x}]))
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (p0 $ AC.[□↦p])
Hwf: well_formed (ex , p) = true
IHAC: evar_is_fresh_in x AC.[□↦p]
→ Γ
  ⊢i AC.[□↦ex , p] <--->
     exists_quantify x AC.[□↦p^{evar:0↦x}]
  using (ExGen := {[x]}, SVSubst := ∅,
         KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed
  (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed
  (exists_quantify x
     (p0 $ AC.[□↦p^{evar:0↦x}]))
Γ
⊢i p0 $ AC.[□↦ex , p] <--->
   exists_quantify x (p0 $ AC.[□↦p^{evar:0↦x}])
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
    {
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (p0 $ AC.[□↦p])
Hwf: well_formed (ex , p) = true
IHAC: evar_is_fresh_in x AC.[□↦p]
→ Γ
  ⊢i AC.[□↦ex , p] <--->
     exists_quantify x AC.[□↦p^{evar:0↦x}]
  using (ExGen := {[x]}, SVSubst := ∅,
         KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed
  (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
well_formed
  (exists_quantify x (p0 $ AC.[□↦p^{evar:0↦x}]))
      wf_auto2.
    }
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (p0 $ AC.[□↦p])
Hwf: well_formed (ex , p) = true
IHAC: evar_is_fresh_in x AC.[□↦p]
→ Γ
  ⊢i AC.[□↦ex , p] <--->
     exists_quantify x AC.[□↦p^{evar:0↦x}]
  using (ExGen := {[x]}, SVSubst := ∅,
         KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed
  (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed
  (exists_quantify x
     (p0 $ AC.[□↦p^{evar:0↦x}]))
Γ
⊢i p0 $ AC.[□↦ex , p] <--->
   exists_quantify x (p0 $ AC.[□↦p^{evar:0↦x}])
using (ExGen := {[x]}, SVSubst := ∅, KT := false)

    apply pf_iff_iff in IHAC; auto.
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (p0 $ AC.[□↦p])
Hwf: well_formed (ex , p) = true
IHAC: ((Γ
  ⊢i AC.[□↦ex , p] --->
     exists_quantify x AC.[□↦p^{evar:0↦x}]
  using (ExGen := {[x]}, SVSubst := ∅,
         KT := false)) *
 (Γ
  ⊢i exists_quantify x AC.[□↦p^{evar:0↦x}] --->
     AC.[□↦ex , p]
  using (ExGen := {[x]}, SVSubst := ∅,
         KT := false)))%type
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed
  (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed
  (exists_quantify x
     (p0 $ AC.[□↦p^{evar:0↦x}]))
Γ
⊢i p0 $ AC.[□↦ex , p] <--->
   exists_quantify x (p0 $ AC.[□↦p^{evar:0↦x}])
using (ExGen := {[x]}, SVSubst := ∅, KT := false)

    destruct IHAC as [IH1 IH2].
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (p0 $ AC.[□↦p])
Hwf: well_formed (ex , p) = true
IH1: Γ ⊢i AC.[□↦ex , p] ---> exists_quantify x AC.[□↦p^{evar:0↦x}]
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
IH2: Γ ⊢i exists_quantify x AC.[□↦p^{evar:0↦x}] ---> AC.[□↦ex , p]
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed
  (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed
  (exists_quantify x
     (p0 $ AC.[□↦p^{evar:0↦x}]))
Γ
⊢i p0 $ AC.[□↦ex , p] <--->
   exists_quantify x (p0 $ AC.[□↦p^{evar:0↦x}])
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
    apply pf_iff_split; auto.
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (p0 $ AC.[□↦p])
Hwf: well_formed (ex , p) = true
IH1: Γ ⊢i AC.[□↦ex , p] ---> exists_quantify x AC.[□↦p^{evar:0↦x}]
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
IH2: Γ ⊢i exists_quantify x AC.[□↦p^{evar:0↦x}] ---> AC.[□↦ex , p]
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed
  (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed
  (exists_quantify x
     (p0 $ AC.[□↦p^{evar:0↦x}]))
Γ
⊢i p0 $ AC.[□↦ex , p] --->
   exists_quantify x (p0 $ AC.[□↦p^{evar:0↦x}])
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (p0 $ AC.[□↦p])
Hwf: well_formed (ex , p) = true
IH1: Γ
⊢i AC.[□↦ex , p] --->
   exists_quantify x AC.[□↦p^{evar:0↦x}]
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
IH2: Γ
⊢i exists_quantify x AC.[□↦p^{evar:0↦x}] --->
   AC.[□↦ex , p]
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed
  (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed
  (exists_quantify x
     (p0 $ AC.[□↦p^{evar:0↦x}]))
Γ
⊢i exists_quantify x (p0 $ AC.[□↦p^{evar:0↦x}]) --->
   p0 $ AC.[□↦ex , p]
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
    +
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (p0 $ AC.[□↦p])
Hwf: well_formed (ex , p) = true
IH1: Γ ⊢i AC.[□↦ex , p] ---> exists_quantify x AC.[□↦p^{evar:0↦x}]
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
IH2: Γ ⊢i exists_quantify x AC.[□↦p^{evar:0↦x}] ---> AC.[□↦ex , p]
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed
  (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed
  (exists_quantify x
     (p0 $ AC.[□↦p^{evar:0↦x}]))
Γ
⊢i p0 $ AC.[□↦ex , p] --->
   exists_quantify x (p0 $ AC.[□↦p^{evar:0↦x}])
using (ExGen := {[x]}, SVSubst := ∅, KT := false) pose proof (H := IH1).
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (p0 $ AC.[□↦p])
Hwf: well_formed (ex , p) = true
IH1: Γ ⊢i AC.[□↦ex , p] ---> exists_quantify x AC.[□↦p^{evar:0↦x}]
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
IH2: Γ ⊢i exists_quantify x AC.[□↦p^{evar:0↦x}] ---> AC.[□↦ex , p]
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed
  (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed
  (exists_quantify x
     (p0 $ AC.[□↦p^{evar:0↦x}]))
H: Γ
⊢i AC.[□↦ex , p] --->
   exists_quantify x AC.[□↦p^{evar:0↦x}]
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Γ
⊢i p0 $ AC.[□↦ex , p] --->
   exists_quantify x (p0 $ AC.[□↦p^{evar:0↦x}])
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
      change constraint in IH1.
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (p0 $ AC.[□↦p])
Hwf: well_formed (ex , p) = true
IH2: Γ ⊢i exists_quantify x AC.[□↦p^{evar:0↦x}] ---> AC.[□↦ex , p]
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦ex , p] ---> exists_quantify x AC.[□↦p^{evar:0↦x}]
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed
  (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed
  (exists_quantify x
     (p0 $ AC.[□↦p^{evar:0↦x}]))
H: Γ
⊢i AC.[□↦ex , p] --->
   exists_quantify x AC.[□↦p^{evar:0↦x}]
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Γ
⊢i p0 $ AC.[□↦ex , p] --->
   exists_quantify x (p0 $ AC.[□↦p^{evar:0↦x}])
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
      apply Framing_right with (ψ := p0) in IH1; auto.
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (p0 $ AC.[□↦p])
Hwf: well_formed (ex , p) = true
IH2: Γ ⊢i exists_quantify x AC.[□↦p^{evar:0↦x}] ---> AC.[□↦ex , p]
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
IH1: Γ ⊢i p0 $ AC.[□↦ex , p] ---> p0 $ exists_quantify x AC.[□↦p^{evar:0↦x}]
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed
  (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed
  (exists_quantify x
     (p0 $ AC.[□↦p^{evar:0↦x}]))
H: Γ
⊢i AC.[□↦ex , p] --->
   exists_quantify x AC.[□↦p^{evar:0↦x}]
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Γ
⊢i p0 $ AC.[□↦ex , p] --->
   exists_quantify x (p0 $ AC.[□↦p^{evar:0↦x}])
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (p0 $ AC.[□↦p])
Hwf: well_formed (ex , p) = true
IH2: Γ
⊢i exists_quantify x AC.[□↦p^{evar:0↦x}] --->
   AC.[□↦ex , p]
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
IH1: Γ
⊢i AC.[□↦ex , p] --->
   exists_quantify x AC.[□↦p^{evar:0↦x}]
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed
  (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed
  (exists_quantify x
     (p0 $ AC.[□↦p^{evar:0↦x}]))
H: Γ
⊢i AC.[□↦ex , p] --->
   exists_quantify x AC.[□↦p^{evar:0↦x}]
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
ProofInfoLe (ExGen := ∅, SVSubst := ∅, KT := false)
  (ExGen := {[x]}, SVSubst := ∅, KT := false)
      2: try_solve_pile.
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (p0 $ AC.[□↦p])
Hwf: well_formed (ex , p) = true
IH2: Γ ⊢i exists_quantify x AC.[□↦p^{evar:0↦x}] ---> AC.[□↦ex , p]
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
IH1: Γ ⊢i p0 $ AC.[□↦ex , p] ---> p0 $ exists_quantify x AC.[□↦p^{evar:0↦x}]
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed
  (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed
  (exists_quantify x
     (p0 $ AC.[□↦p^{evar:0↦x}]))
H: Γ
⊢i AC.[□↦ex , p] --->
   exists_quantify x AC.[□↦p^{evar:0↦x}]
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Γ
⊢i p0 $ AC.[□↦ex , p] --->
   exists_quantify x (p0 $ AC.[□↦p^{evar:0↦x}])
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
      eapply syllogism_meta.
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (p0 $ AC.[□↦p])
Hwf: well_formed (ex , p) = true
IH2: Γ ⊢i exists_quantify x AC.[□↦p^{evar:0↦x}] ---> AC.[□↦ex , p]
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
IH1: Γ ⊢i p0 $ AC.[□↦ex , p] ---> p0 $ exists_quantify x AC.[□↦p^{evar:0↦x}]
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed
  (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed
  (exists_quantify x
     (p0 $ AC.[□↦p^{evar:0↦x}]))
H: Γ
⊢i AC.[□↦ex , p] --->
   exists_quantify x AC.[□↦p^{evar:0↦x}]
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
well_formed (p0 $ AC.[□↦ex , p])
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (p0 $ AC.[□↦p])
Hwf: well_formed (ex , p) = true
IH2: Γ
⊢i exists_quantify x AC.[□↦p^{evar:0↦x}] --->
   AC.[□↦ex , p]
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
IH1: Γ
⊢i p0 $ AC.[□↦ex , p] --->
   p0 $ exists_quantify x AC.[□↦p^{evar:0↦x}]
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed
  (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed
  (exists_quantify x
     (p0 $ AC.[□↦p^{evar:0↦x}]))
H: Γ
⊢i AC.[□↦ex , p] --->
   exists_quantify x AC.[□↦p^{evar:0↦x}]
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
well_formed ?B
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (p0 $ AC.[□↦p])
Hwf: well_formed (ex , p) = true
IH2: Γ
⊢i exists_quantify x AC.[□↦p^{evar:0↦x}] --->
   AC.[□↦ex , p]
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
IH1: Γ
⊢i p0 $ AC.[□↦ex , p] --->
   p0 $ exists_quantify x AC.[□↦p^{evar:0↦x}]
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed
  (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed
  (exists_quantify x
     (p0 $ AC.[□↦p^{evar:0↦x}]))
H: Γ
⊢i AC.[□↦ex , p] --->
   exists_quantify x AC.[□↦p^{evar:0↦x}]
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
well_formed
  (exists_quantify x (p0 $ AC.[□↦p^{evar:0↦x}]))
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (p0 $ AC.[□↦p])
Hwf: well_formed (ex , p) = true
IH2: Γ
⊢i exists_quantify x AC.[□↦p^{evar:0↦x}] --->
   AC.[□↦ex , p]
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
IH1: Γ
⊢i p0 $ AC.[□↦ex , p] --->
   p0 $ exists_quantify x AC.[□↦p^{evar:0↦x}]
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed
  (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed
  (exists_quantify x
     (p0 $ AC.[□↦p^{evar:0↦x}]))
H: Γ
⊢i AC.[□↦ex , p] --->
   exists_quantify x AC.[□↦p^{evar:0↦x}]
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Γ ⊢i p0 $ AC.[□↦ex , p] ---> ?B
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (p0 $ AC.[□↦p])
Hwf: well_formed (ex , p) = true
IH2: Γ
⊢i exists_quantify x AC.[□↦p^{evar:0↦x}] --->
   AC.[□↦ex , p]
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
IH1: Γ
⊢i p0 $ AC.[□↦ex , p] --->
   p0 $ exists_quantify x AC.[□↦p^{evar:0↦x}]
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed
  (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed
  (exists_quantify x
     (p0 $ AC.[□↦p^{evar:0↦x}]))
H: Γ
⊢i AC.[□↦ex , p] --->
   exists_quantify x AC.[□↦p^{evar:0↦x}]
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Γ
⊢i ?B --->
   exists_quantify x (p0 $ AC.[□↦p^{evar:0↦x}])
using (ExGen := {[x]}, SVSubst := ∅, KT := false) 4: apply IH1.
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (p0 $ AC.[□↦p])
Hwf: well_formed (ex , p) = true
IH2: Γ ⊢i exists_quantify x AC.[□↦p^{evar:0↦x}] ---> AC.[□↦ex , p]
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
IH1: Γ ⊢i p0 $ AC.[□↦ex , p] ---> p0 $ exists_quantify x AC.[□↦p^{evar:0↦x}]
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed
  (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed
  (exists_quantify x
     (p0 $ AC.[□↦p^{evar:0↦x}]))
H: Γ
⊢i AC.[□↦ex , p] --->
   exists_quantify x AC.[□↦p^{evar:0↦x}]
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
well_formed (p0 $ AC.[□↦ex , p])
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (p0 $ AC.[□↦p])
Hwf: well_formed (ex , p) = true
IH2: Γ
⊢i exists_quantify x AC.[□↦p^{evar:0↦x}] --->
   AC.[□↦ex , p]
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
IH1: Γ
⊢i p0 $ AC.[□↦ex , p] --->
   p0 $ exists_quantify x AC.[□↦p^{evar:0↦x}]
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed
  (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed
  (exists_quantify x
     (p0 $ AC.[□↦p^{evar:0↦x}]))
H: Γ
⊢i AC.[□↦ex , p] --->
   exists_quantify x AC.[□↦p^{evar:0↦x}]
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
well_formed
  (p0 $ exists_quantify x AC.[□↦p^{evar:0↦x}])
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (p0 $ AC.[□↦p])
Hwf: well_formed (ex , p) = true
IH2: Γ
⊢i exists_quantify x AC.[□↦p^{evar:0↦x}] --->
   AC.[□↦ex , p]
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
IH1: Γ
⊢i p0 $ AC.[□↦ex , p] --->
   p0 $ exists_quantify x AC.[□↦p^{evar:0↦x}]
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed
  (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed
  (exists_quantify x
     (p0 $ AC.[□↦p^{evar:0↦x}]))
H: Γ
⊢i AC.[□↦ex , p] --->
   exists_quantify x AC.[□↦p^{evar:0↦x}]
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
well_formed
  (exists_quantify x (p0 $ AC.[□↦p^{evar:0↦x}]))
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (p0 $ AC.[□↦p])
Hwf: well_formed (ex , p) = true
IH2: Γ
⊢i exists_quantify x AC.[□↦p^{evar:0↦x}] --->
   AC.[□↦ex , p]
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
IH1: Γ
⊢i p0 $ AC.[□↦ex , p] --->
   p0 $ exists_quantify x AC.[□↦p^{evar:0↦x}]
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed
  (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed
  (exists_quantify x
     (p0 $ AC.[□↦p^{evar:0↦x}]))
H: Γ
⊢i AC.[□↦ex , p] --->
   exists_quantify x AC.[□↦p^{evar:0↦x}]
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Γ
⊢i p0 $ exists_quantify x AC.[□↦p^{evar:0↦x}] --->
   exists_quantify x (p0 $ AC.[□↦p^{evar:0↦x}])
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
      1-3: wf_auto2.
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (p0 $ AC.[□↦p])
Hwf: well_formed (ex , p) = true
IH2: Γ ⊢i exists_quantify x AC.[□↦p^{evar:0↦x}] ---> AC.[□↦ex , p]
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
IH1: Γ ⊢i p0 $ AC.[□↦ex , p] ---> p0 $ exists_quantify x AC.[□↦p^{evar:0↦x}]
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed
  (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed
  (exists_quantify x
     (p0 $ AC.[□↦p^{evar:0↦x}]))
H: Γ
⊢i AC.[□↦ex , p] --->
   exists_quantify x AC.[□↦p^{evar:0↦x}]
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Γ
⊢i p0 $ exists_quantify x AC.[□↦p^{evar:0↦x}] --->
   exists_quantify x (p0 $ AC.[□↦p^{evar:0↦x}])
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
      remember (subst_ctx AC (p^{evar: 0 ↦ x})) as p'.
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (p0 $ AC.[□↦p])
Hwf: well_formed (ex , p) = true
p': Pattern
Heqp': p' = AC.[□↦p^{evar:0↦x}]
IH2: Γ ⊢i exists_quantify x p' ---> AC.[□↦ex , p]
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
IH1: Γ
⊢i p0 $ AC.[□↦ex , p] --->
   p0 $ exists_quantify x p'
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed (exists_quantify x p')
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed (exists_quantify x (p0 $ p'))
H: Γ ⊢i AC.[□↦ex , p] ---> exists_quantify x p'
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Γ
⊢i p0 $ exists_quantify x p' --->
   exists_quantify x (p0 $ p')
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
      unfold exists_quantify.
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (p0 $ AC.[□↦p])
Hwf: well_formed (ex , p) = true
p': Pattern
Heqp': p' = AC.[□↦p^{evar:0↦x}]
IH2: Γ ⊢i exists_quantify x p' ---> AC.[□↦ex , p]
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
IH1: Γ
⊢i p0 $ AC.[□↦ex , p] --->
   p0 $ exists_quantify x p'
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed (exists_quantify x p')
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed (exists_quantify x (p0 $ p'))
H: Γ ⊢i AC.[□↦ex , p] ---> exists_quantify x p'
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Γ
⊢i p0 $ (ex , p'^{{evar:x↦0}}) --->
   (ex , (p0 $ p')^{{evar:x↦0}})
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
      simpl.
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (p0 $ AC.[□↦p])
Hwf: well_formed (ex , p) = true
p': Pattern
Heqp': p' = AC.[□↦p^{evar:0↦x}]
IH2: Γ ⊢i exists_quantify x p' ---> AC.[□↦ex , p]
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
IH1: Γ
⊢i p0 $ AC.[□↦ex , p] --->
   p0 $ exists_quantify x p'
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed (exists_quantify x p')
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed (exists_quantify x (p0 $ p'))
H: Γ ⊢i AC.[□↦ex , p] ---> exists_quantify x p'
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Γ
⊢i p0 $ (ex , p'^{{evar:x↦0}}) --->
   (ex , p0^{{evar:x↦0}} $ p'^{{evar:x↦0}})
using (ExGen := {[x]}, SVSubst := ∅, KT := false) rewrite [p0^{{evar: x ↦ 0}}]evar_quantify_fresh.
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (p0 $ AC.[□↦p])
Hwf: well_formed (ex , p) = true
p': Pattern
Heqp': p' = AC.[□↦p^{evar:0↦x}]
IH2: Γ ⊢i exists_quantify x p' ---> AC.[□↦ex , p]
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
IH1: Γ
⊢i p0 $ AC.[□↦ex , p] --->
   p0 $ exists_quantify x p'
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed (exists_quantify x p')
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed (exists_quantify x (p0 $ p'))
H: Γ ⊢i AC.[□↦ex , p] ---> exists_quantify x p'
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
evar_is_fresh_in x p0
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (p0 $ AC.[□↦p])
Hwf: well_formed (ex , p) = true
p': Pattern
Heqp': p' = AC.[□↦p^{evar:0↦x}]
IH2: Γ ⊢i exists_quantify x p' ---> AC.[□↦ex , p]
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
IH1: Γ
⊢i p0 $ AC.[□↦ex , p] --->
   p0 $ exists_quantify x p'
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed (exists_quantify x p')
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed (exists_quantify x (p0 $ p'))
H: Γ ⊢i AC.[□↦ex , p] ---> exists_quantify x p'
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Γ
⊢i p0 $ (ex , p'^{{evar:x↦0}}) --->
   (ex , p0 $ p'^{{evar:x↦0}})
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
      {
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (p0 $ AC.[□↦p])
Hwf: well_formed (ex , p) = true
p': Pattern
Heqp': p' = AC.[□↦p^{evar:0↦x}]
IH2: Γ ⊢i exists_quantify x p' ---> AC.[□↦ex , p]
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
IH1: Γ
⊢i p0 $ AC.[□↦ex , p] --->
   p0 $ exists_quantify x p'
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed (exists_quantify x p')
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed (exists_quantify x (p0 $ p'))
H: Γ ⊢i AC.[□↦ex , p] ---> exists_quantify x p'
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
evar_is_fresh_in x p0 eapply evar_is_fresh_in_app_l.
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (p0 $ AC.[□↦p])
Hwf: well_formed (ex , p) = true
p': Pattern
Heqp': p' = AC.[□↦p^{evar:0↦x}]
IH2: Γ ⊢i exists_quantify x p' ---> AC.[□↦ex , p]
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
IH1: Γ
⊢i p0 $ AC.[□↦ex , p] --->
   p0 $ exists_quantify x p'
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed (exists_quantify x p')
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed (exists_quantify x (p0 $ p'))
H: Γ ⊢i AC.[□↦ex , p] ---> exists_quantify x p'
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
evar_is_fresh_in x (p0 $ ?ϕ₂) apply Hx. }
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (p0 $ AC.[□↦p])
Hwf: well_formed (ex , p) = true
p': Pattern
Heqp': p' = AC.[□↦p^{evar:0↦x}]
IH2: Γ ⊢i exists_quantify x p' ---> AC.[□↦ex , p]
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
IH1: Γ
⊢i p0 $ AC.[□↦ex , p] --->
   p0 $ exists_quantify x p'
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed (exists_quantify x p')
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed (exists_quantify x (p0 $ p'))
H: Γ ⊢i AC.[□↦ex , p] ---> exists_quantify x p'
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Γ
⊢i p0 $ (ex , p'^{{evar:x↦0}}) --->
   (ex , p0 $ p'^{{evar:x↦0}})
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
      useBasicReasoning.
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (p0 $ AC.[□↦p])
Hwf: well_formed (ex , p) = true
p': Pattern
Heqp': p' = AC.[□↦p^{evar:0↦x}]
IH2: Γ ⊢i exists_quantify x p' ---> AC.[□↦ex , p]
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
IH1: Γ
⊢i p0 $ AC.[□↦ex , p] --->
   p0 $ exists_quantify x p'
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed (exists_quantify x p')
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed (exists_quantify x (p0 $ p'))
H: Γ ⊢i AC.[□↦ex , p] ---> exists_quantify x p'
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Γ
⊢i p0 $ (ex , p'^{{evar:x↦0}}) --->
   (ex , p0 $ p'^{{evar:x↦0}}) using BasicReasoning
      apply Prop_ex_right.
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (p0 $ AC.[□↦p])
Hwf: well_formed (ex , p) = true
p': Pattern
Heqp': p' = AC.[□↦p^{evar:0↦x}]
IH2: Γ ⊢i exists_quantify x p' ---> AC.[□↦ex , p]
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
IH1: Γ
⊢i p0 $ AC.[□↦ex , p] --->
   p0 $ exists_quantify x p'
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed (exists_quantify x p')
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed (exists_quantify x (p0 $ p'))
H: Γ ⊢i AC.[□↦ex , p] ---> exists_quantify x p'
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
well_formed (ex , p'^{{evar:x↦0}})
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (p0 $ AC.[□↦p])
Hwf: well_formed (ex , p) = true
p': Pattern
Heqp': p' = AC.[□↦p^{evar:0↦x}]
IH2: Γ ⊢i exists_quantify x p' ---> AC.[□↦ex , p]
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
IH1: Γ
⊢i p0 $ AC.[□↦ex , p] --->
   p0 $ exists_quantify x p'
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed (exists_quantify x p')
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed (exists_quantify x (p0 $ p'))
H: Γ ⊢i AC.[□↦ex , p] ---> exists_quantify x p'
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
well_formed p0 wf_auto2.
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (p0 $ AC.[□↦p])
Hwf: well_formed (ex , p) = true
p': Pattern
Heqp': p' = AC.[□↦p^{evar:0↦x}]
IH2: Γ ⊢i exists_quantify x p' ---> AC.[□↦ex , p]
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
IH1: Γ
⊢i p0 $ AC.[□↦ex , p] --->
   p0 $ exists_quantify x p'
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed (exists_quantify x p')
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed (exists_quantify x (p0 $ p'))
H: Γ ⊢i AC.[□↦ex , p] ---> exists_quantify x p'
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
well_formed p0 wf_auto2.
    +
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (p0 $ AC.[□↦p])
Hwf: well_formed (ex , p) = true
IH1: Γ ⊢i AC.[□↦ex , p] ---> exists_quantify x AC.[□↦p^{evar:0↦x}]
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
IH2: Γ ⊢i exists_quantify x AC.[□↦p^{evar:0↦x}] ---> AC.[□↦ex , p]
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed
  (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed
  (exists_quantify x
     (p0 $ AC.[□↦p^{evar:0↦x}]))
Γ
⊢i exists_quantify x (p0 $ AC.[□↦p^{evar:0↦x}]) --->
   p0 $ AC.[□↦ex , p]
using (ExGen := {[x]}, SVSubst := ∅, KT := false) clear IH1.
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (p0 $ AC.[□↦p])
Hwf: well_formed (ex , p) = true
IH2: Γ ⊢i exists_quantify x AC.[□↦p^{evar:0↦x}] ---> AC.[□↦ex , p]
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed
  (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed
  (exists_quantify x
     (p0 $ AC.[□↦p^{evar:0↦x}]))
Γ
⊢i exists_quantify x (p0 $ AC.[□↦p^{evar:0↦x}]) --->
   p0 $ AC.[□↦ex , p]
using (ExGen := {[x]}, SVSubst := ∅, KT := false)

      change constraint in IH2.
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (p0 $ AC.[□↦p])
Hwf: well_formed (ex , p) = true
IH2: Γ ⊢i exists_quantify x AC.[□↦p^{evar:0↦x}] ---> AC.[□↦ex , p]
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed
  (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed
  (exists_quantify x
     (p0 $ AC.[□↦p^{evar:0↦x}]))
Γ
⊢i exists_quantify x (p0 $ AC.[□↦p^{evar:0↦x}]) --->
   p0 $ AC.[□↦ex , p]
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
      eapply (Framing_right _ _ _ _ _ Prf) in IH2.
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (p0 $ AC.[□↦p])
Hwf: well_formed (ex , p) = true
IH2: Γ ⊢i p0 $ exists_quantify x AC.[□↦p^{evar:0↦x}] ---> p0 $ AC.[□↦ex , p]
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed
  (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed
  (exists_quantify x
     (p0 $ AC.[□↦p^{evar:0↦x}]))
Γ
⊢i exists_quantify x (p0 $ AC.[□↦p^{evar:0↦x}]) --->
   p0 $ AC.[□↦ex , p]
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
      eapply syllogism_meta.
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (p0 $ AC.[□↦p])
Hwf: well_formed (ex , p) = true
IH2: Γ ⊢i p0 $ exists_quantify x AC.[□↦p^{evar:0↦x}] ---> p0 $ AC.[□↦ex , p]
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed
  (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed
  (exists_quantify x
     (p0 $ AC.[□↦p^{evar:0↦x}]))
well_formed
  (exists_quantify x (p0 $ AC.[□↦p^{evar:0↦x}]))
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (p0 $ AC.[□↦p])
Hwf: well_formed (ex , p) = true
IH2: Γ
⊢i p0 $ exists_quantify x AC.[□↦p^{evar:0↦x}] --->
   p0 $ AC.[□↦ex , p]
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed
  (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed
  (exists_quantify x
     (p0 $ AC.[□↦p^{evar:0↦x}]))
well_formed ?B
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (p0 $ AC.[□↦p])
Hwf: well_formed (ex , p) = true
IH2: Γ
⊢i p0 $ exists_quantify x AC.[□↦p^{evar:0↦x}] --->
   p0 $ AC.[□↦ex , p]
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed
  (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed
  (exists_quantify x
     (p0 $ AC.[□↦p^{evar:0↦x}]))
well_formed (p0 $ AC.[□↦ex , p])
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (p0 $ AC.[□↦p])
Hwf: well_formed (ex , p) = true
IH2: Γ
⊢i p0 $ exists_quantify x AC.[□↦p^{evar:0↦x}] --->
   p0 $ AC.[□↦ex , p]
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed
  (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed
  (exists_quantify x
     (p0 $ AC.[□↦p^{evar:0↦x}]))
Γ
⊢i exists_quantify x (p0 $ AC.[□↦p^{evar:0↦x}]) --->
   ?B
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (p0 $ AC.[□↦p])
Hwf: well_formed (ex , p) = true
IH2: Γ
⊢i p0 $ exists_quantify x AC.[□↦p^{evar:0↦x}] --->
   p0 $ AC.[□↦ex , p]
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed
  (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed
  (exists_quantify x
     (p0 $ AC.[□↦p^{evar:0↦x}]))
Γ ⊢i ?B ---> p0 $ AC.[□↦ex , p]
using (ExGen := {[x]}, SVSubst := ∅, KT := false) 5: eapply IH2.
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (p0 $ AC.[□↦p])
Hwf: well_formed (ex , p) = true
IH2: Γ ⊢i p0 $ exists_quantify x AC.[□↦p^{evar:0↦x}] ---> p0 $ AC.[□↦ex , p]
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed
  (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed
  (exists_quantify x
     (p0 $ AC.[□↦p^{evar:0↦x}]))
well_formed
  (exists_quantify x (p0 $ AC.[□↦p^{evar:0↦x}]))
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (p0 $ AC.[□↦p])
Hwf: well_formed (ex , p) = true
IH2: Γ
⊢i p0 $ exists_quantify x AC.[□↦p^{evar:0↦x}] --->
   p0 $ AC.[□↦ex , p]
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed
  (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed
  (exists_quantify x
     (p0 $ AC.[□↦p^{evar:0↦x}]))
well_formed
  (p0 $ exists_quantify x AC.[□↦p^{evar:0↦x}])
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (p0 $ AC.[□↦p])
Hwf: well_formed (ex , p) = true
IH2: Γ
⊢i p0 $ exists_quantify x AC.[□↦p^{evar:0↦x}] --->
   p0 $ AC.[□↦ex , p]
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed
  (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed
  (exists_quantify x
     (p0 $ AC.[□↦p^{evar:0↦x}]))
well_formed (p0 $ AC.[□↦ex , p])
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (p0 $ AC.[□↦p])
Hwf: well_formed (ex , p) = true
IH2: Γ
⊢i p0 $ exists_quantify x AC.[□↦p^{evar:0↦x}] --->
   p0 $ AC.[□↦ex , p]
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed
  (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed
  (exists_quantify x
     (p0 $ AC.[□↦p^{evar:0↦x}]))
Γ
⊢i exists_quantify x (p0 $ AC.[□↦p^{evar:0↦x}]) --->
   p0 $ exists_quantify x AC.[□↦p^{evar:0↦x}]
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
      1-3: wf_auto2.
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (p0 $ AC.[□↦p])
Hwf: well_formed (ex , p) = true
IH2: Γ ⊢i p0 $ exists_quantify x AC.[□↦p^{evar:0↦x}] ---> p0 $ AC.[□↦ex , p]
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed
  (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed
  (exists_quantify x
     (p0 $ AC.[□↦p^{evar:0↦x}]))
Γ
⊢i exists_quantify x (p0 $ AC.[□↦p^{evar:0↦x}]) --->
   p0 $ exists_quantify x AC.[□↦p^{evar:0↦x}]
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
      Unshelve.
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (p0 $ AC.[□↦p])
Hwf: well_formed (ex , p) = true
IH2: Γ ⊢i p0 $ exists_quantify x AC.[□↦p^{evar:0↦x}] ---> p0 $ AC.[□↦ex , p]
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed
  (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed
  (exists_quantify x
     (p0 $ AC.[□↦p^{evar:0↦x}]))
Γ
⊢i exists_quantify x (p0 $ AC.[□↦p^{evar:0↦x}]) --->
   p0 $ exists_quantify x AC.[□↦p^{evar:0↦x}]
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (p0 $ AC.[□↦p])
Hwf: well_formed (ex , p) = true
IH2: Γ
⊢i exists_quantify x AC.[□↦p^{evar:0↦x}] --->
   AC.[□↦ex , p]
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed
  (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed
  (exists_quantify x
     (p0 $ AC.[□↦p^{evar:0↦x}]))
ProofInfoLe (ExGen := ∅, SVSubst := ∅, KT := false)
  (ExGen := {[x]}, SVSubst := ∅, KT := false)
      2: {
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (p0 $ AC.[□↦p])
Hwf: well_formed (ex , p) = true
IH2: Γ ⊢i exists_quantify x AC.[□↦p^{evar:0↦x}] ---> AC.[□↦ex , p]
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed
  (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed
  (exists_quantify x
     (p0 $ AC.[□↦p^{evar:0↦x}]))
ProofInfoLe (ExGen := ∅, SVSubst := ∅, KT := false)
  (ExGen := {[x]}, SVSubst := ∅, KT := false) try_solve_pile. }
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (p0 $ AC.[□↦p])
Hwf: well_formed (ex , p) = true
IH2: Γ ⊢i p0 $ exists_quantify x AC.[□↦p^{evar:0↦x}] ---> p0 $ AC.[□↦ex , p]
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed
  (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed
  (exists_quantify x
     (p0 $ AC.[□↦p^{evar:0↦x}]))
Γ
⊢i exists_quantify x (p0 $ AC.[□↦p^{evar:0↦x}]) --->
   p0 $ exists_quantify x AC.[□↦p^{evar:0↦x}]
using (ExGen := {[x]}, SVSubst := ∅, KT := false)

      apply Ex_gen; auto.
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (p0 $ AC.[□↦p])
Hwf: well_formed (ex , p) = true
IH2: Γ ⊢i p0 $ exists_quantify x AC.[□↦p^{evar:0↦x}] ---> p0 $ AC.[□↦ex , p]
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed
  (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed
  (exists_quantify x
     (p0 $ AC.[□↦p^{evar:0↦x}]))
ProofInfoLe
  (ExGen := {[x]}, SVSubst := ∅, KT := false)
  (ExGen := {[x]}, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (p0 $ AC.[□↦p])
Hwf: well_formed (ex , p) = true
IH2: Γ
⊢i p0 $ exists_quantify x AC.[□↦p^{evar:0↦x}] --->
   p0 $ AC.[□↦ex , p]
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed
  (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed
  (exists_quantify x
     (p0 $ AC.[□↦p^{evar:0↦x}]))
x
∉ free_evars
    (p0 $ exists_quantify x AC.[□↦p^{evar:0↦x}])
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (p0 $ AC.[□↦p])
Hwf: well_formed (ex , p) = true
IH2: Γ
⊢i p0 $ exists_quantify x AC.[□↦p^{evar:0↦x}] --->
   p0 $ AC.[□↦ex , p]
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed
  (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed
  (exists_quantify x
     (p0 $ AC.[□↦p^{evar:0↦x}]))
Γ
⊢i p0 $ AC.[□↦p^{evar:0↦x}] --->
   p0 $ exists_quantify x AC.[□↦p^{evar:0↦x}]
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
      {
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (p0 $ AC.[□↦p])
Hwf: well_formed (ex , p) = true
IH2: Γ ⊢i p0 $ exists_quantify x AC.[□↦p^{evar:0↦x}] ---> p0 $ AC.[□↦ex , p]
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed
  (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed
  (exists_quantify x
     (p0 $ AC.[□↦p^{evar:0↦x}]))
ProofInfoLe
  (ExGen := {[x]}, SVSubst := ∅, KT := false)
  (ExGen := {[x]}, SVSubst := ∅, KT := false) try_solve_pile. }
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (p0 $ AC.[□↦p])
Hwf: well_formed (ex , p) = true
IH2: Γ ⊢i p0 $ exists_quantify x AC.[□↦p^{evar:0↦x}] ---> p0 $ AC.[□↦ex , p]
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed
  (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed
  (exists_quantify x
     (p0 $ AC.[□↦p^{evar:0↦x}]))
x
∉ free_evars
    (p0 $ exists_quantify x AC.[□↦p^{evar:0↦x}])
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (p0 $ AC.[□↦p])
Hwf: well_formed (ex , p) = true
IH2: Γ
⊢i p0 $ exists_quantify x AC.[□↦p^{evar:0↦x}] --->
   p0 $ AC.[□↦ex , p]
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed
  (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed
  (exists_quantify x
     (p0 $ AC.[□↦p^{evar:0↦x}]))
Γ
⊢i p0 $ AC.[□↦p^{evar:0↦x}] --->
   p0 $ exists_quantify x AC.[□↦p^{evar:0↦x}]
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
      1: {
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (p0 $ AC.[□↦p])
Hwf: well_formed (ex , p) = true
IH2: Γ ⊢i p0 $ exists_quantify x AC.[□↦p^{evar:0↦x}] ---> p0 $ AC.[□↦ex , p]
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed
  (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed
  (exists_quantify x
     (p0 $ AC.[□↦p^{evar:0↦x}]))
x
∉ free_evars
    (p0 $ exists_quantify x AC.[□↦p^{evar:0↦x}])
        unfold exists_quantify.
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (p0 $ AC.[□↦p])
Hwf: well_formed (ex , p) = true
IH2: Γ ⊢i p0 $ exists_quantify x AC.[□↦p^{evar:0↦x}] ---> p0 $ AC.[□↦ex , p]
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed
  (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed
  (exists_quantify x
     (p0 $ AC.[□↦p^{evar:0↦x}]))
x
∉ free_evars
    (p0 $ (ex , AC.[□↦p^{evar:0↦x}]^{{evar:x↦0}}))
        simpl.
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (p0 $ AC.[□↦p])
Hwf: well_formed (ex , p) = true
IH2: Γ ⊢i p0 $ exists_quantify x AC.[□↦p^{evar:0↦x}] ---> p0 $ AC.[□↦ex , p]
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed
  (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed
  (exists_quantify x
     (p0 $ AC.[□↦p^{evar:0↦x}]))
x
∉ free_evars p0
  ∪ free_evars AC.[□↦p^{evar:0↦x}]^{{evar:x↦0}}
        rewrite free_evars_evar_quantify.
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (p0 $ AC.[□↦p])
Hwf: well_formed (ex , p) = true
IH2: Γ ⊢i p0 $ exists_quantify x AC.[□↦p^{evar:0↦x}] ---> p0 $ AC.[□↦ex , p]
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed
  (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed
  (exists_quantify x
     (p0 $ AC.[□↦p^{evar:0↦x}]))
x
∉ free_evars p0
  ∪ free_evars AC.[□↦p^{evar:0↦x}] ∖ {[x]}
        unfold evar_is_fresh_in in Hx.
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p: Pattern
x: evar
Hx: x ∉ free_evars (p0 $ AC.[□↦p])
Hwf: well_formed (ex , p) = true
IH2: Γ ⊢i p0 $ exists_quantify x AC.[□↦p^{evar:0↦x}] ---> p0 $ AC.[□↦ex , p]
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed
  (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed
  (exists_quantify x
     (p0 $ AC.[□↦p^{evar:0↦x}]))
x
∉ free_evars p0
  ∪ free_evars AC.[□↦p^{evar:0↦x}] ∖ {[x]} simpl in Hx.
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p: Pattern
x: evar
Hx: x ∉ free_evars p0 ∪ free_evars AC.[□↦p]
Hwf: well_formed (ex , p) = true
IH2: Γ ⊢i p0 $ exists_quantify x AC.[□↦p^{evar:0↦x}] ---> p0 $ AC.[□↦ex , p]
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed
  (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed
  (exists_quantify x
     (p0 $ AC.[□↦p^{evar:0↦x}]))
x
∉ free_evars p0
  ∪ free_evars AC.[□↦p^{evar:0↦x}] ∖ {[x]} clear -Hx.
Σ: Signature
p0: Pattern
AC: Application_context
p: Pattern
x: evar
Hx: x ∉ free_evars p0 ∪ free_evars AC.[□↦p]
x
∉ free_evars p0
  ∪ free_evars AC.[□↦p^{evar:0↦x}] ∖ {[x]}
        set_solver.
      }
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (p0 $ AC.[□↦p])
Hwf: well_formed (ex , p) = true
IH2: Γ ⊢i p0 $ exists_quantify x AC.[□↦p^{evar:0↦x}] ---> p0 $ AC.[□↦ex , p]
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed
  (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed
  (exists_quantify x
     (p0 $ AC.[□↦p^{evar:0↦x}]))
Γ
⊢i p0 $ AC.[□↦p^{evar:0↦x}] --->
   p0 $ exists_quantify x AC.[□↦p^{evar:0↦x}]
using (ExGen := {[x]}, SVSubst := ∅, KT := false)

      eapply (Framing_right _ _ _ _ _ Prf).
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (p0 $ AC.[□↦p])
Hwf: well_formed (ex , p) = true
IH2: Γ ⊢i p0 $ exists_quantify x AC.[□↦p^{evar:0↦x}] ---> p0 $ AC.[□↦ex , p]
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed
  (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed
  (exists_quantify x
     (p0 $ AC.[□↦p^{evar:0↦x}]))
Γ
⊢i AC.[□↦p^{evar:0↦x}] --->
   exists_quantify x AC.[□↦p^{evar:0↦x}]
using (ExGen := {[x]}, SVSubst := ∅, KT := false) Unshelve.
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (p0 $ AC.[□↦p])
Hwf: well_formed (ex , p) = true
IH2: Γ ⊢i p0 $ exists_quantify x AC.[□↦p^{evar:0↦x}] ---> p0 $ AC.[□↦ex , p]
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed
  (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed
  (exists_quantify x
     (p0 $ AC.[□↦p^{evar:0↦x}]))
Γ
⊢i AC.[□↦p^{evar:0↦x}] --->
   exists_quantify x AC.[□↦p^{evar:0↦x}]
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (p0 $ AC.[□↦p])
Hwf: well_formed (ex , p) = true
IH2: Γ
⊢i p0 $ exists_quantify x AC.[□↦p^{evar:0↦x}] --->
   p0 $ AC.[□↦ex , p]
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed
  (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed
  (exists_quantify x
     (p0 $ AC.[□↦p^{evar:0↦x}]))
ProofInfoLe (ExGen := ∅, SVSubst := ∅, KT := false)
  (ExGen := {[x]}, SVSubst := ∅, KT := false)
      2: {
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (p0 $ AC.[□↦p])
Hwf: well_formed (ex , p) = true
IH2: Γ ⊢i p0 $ exists_quantify x AC.[□↦p^{evar:0↦x}] ---> p0 $ AC.[□↦ex , p]
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed
  (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed
  (exists_quantify x
     (p0 $ AC.[□↦p^{evar:0↦x}]))
ProofInfoLe (ExGen := ∅, SVSubst := ∅, KT := false)
  (ExGen := {[x]}, SVSubst := ∅, KT := false) try_solve_pile. }
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (p0 $ AC.[□↦p])
Hwf: well_formed (ex , p) = true
IH2: Γ ⊢i p0 $ exists_quantify x AC.[□↦p^{evar:0↦x}] ---> p0 $ AC.[□↦ex , p]
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed
  (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed
  (exists_quantify x
     (p0 $ AC.[□↦p^{evar:0↦x}]))
Γ
⊢i AC.[□↦p^{evar:0↦x}] --->
   exists_quantify x AC.[□↦p^{evar:0↦x}]
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
      {
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (p0 $ AC.[□↦p])
Hwf: well_formed (ex , p) = true
IH2: Γ ⊢i p0 $ exists_quantify x AC.[□↦p^{evar:0↦x}] ---> p0 $ AC.[□↦ex , p]
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed
  (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed
  (exists_quantify x
     (p0 $ AC.[□↦p^{evar:0↦x}]))
Γ
⊢i AC.[□↦p^{evar:0↦x}] --->
   exists_quantify x AC.[□↦p^{evar:0↦x}]
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
      unfold evar_open.
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (p0 $ AC.[□↦p])
Hwf: well_formed (ex , p) = true
IH2: Γ ⊢i p0 $ exists_quantify x AC.[□↦p^{evar:0↦x}] ---> p0 $ AC.[□↦ex , p]
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed
  (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed
  (exists_quantify x
     (p0 $ AC.[□↦p^{evar:0↦x}]))
Γ
⊢i AC.[□↦p^[evar:0↦patt_free_evar x]] --->
   exists_quantify x
     AC.[□↦p^[evar:0↦patt_free_evar x]]
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
      rewrite subst_ctx_bevar_subst.
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (p0 $ AC.[□↦p])
Hwf: well_formed (ex , p) = true
IH2: Γ ⊢i p0 $ exists_quantify x AC.[□↦p^{evar:0↦x}] ---> p0 $ AC.[□↦ex , p]
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed
  (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed
  (exists_quantify x
     (p0 $ AC.[□↦p^{evar:0↦x}]))
Γ
⊢i AC.[□↦p]^[evar:0↦patt_free_evar x] --->
   exists_quantify x
     AC.[□↦p]^[evar:0↦patt_free_evar x]
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
      unfold exists_quantify.
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (p0 $ AC.[□↦p])
Hwf: well_formed (ex , p) = true
IH2: Γ ⊢i p0 $ exists_quantify x AC.[□↦p^{evar:0↦x}] ---> p0 $ AC.[□↦ex , p]
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed
  (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed
  (exists_quantify x
     (p0 $ AC.[□↦p^{evar:0↦x}]))
Γ
⊢i AC.[□↦p]^[evar:0↦patt_free_evar x] --->
   (ex ,
    AC.[□↦p]^[evar:0↦patt_free_evar x]^{{evar:x↦0}})
using (ExGen := {[x]}, SVSubst := ∅, KT := false) simpl.
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (p0 $ AC.[□↦p])
Hwf: well_formed (ex , p) = true
IH2: Γ ⊢i p0 $ exists_quantify x AC.[□↦p^{evar:0↦x}] ---> p0 $ AC.[□↦ex , p]
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed
  (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed
  (exists_quantify x
     (p0 $ AC.[□↦p^{evar:0↦x}]))
Γ
⊢i AC.[□↦p]^[evar:0↦patt_free_evar x] --->
   (ex ,
    AC.[□↦p]^[evar:0↦patt_free_evar x]^{{evar:x↦0}})
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
      fold ((subst_ctx AC p)^{evar: 0 ↦ x}).
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (p0 $ AC.[□↦p])
Hwf: well_formed (ex , p) = true
IH2: Γ ⊢i p0 $ exists_quantify x AC.[□↦p^{evar:0↦x}] ---> p0 $ AC.[□↦ex , p]
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed
  (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed
  (exists_quantify x
     (p0 $ AC.[□↦p^{evar:0↦x}]))
Γ
⊢i AC.[□↦p]^{evar:0↦x} --->
   (ex , AC.[□↦p]^{evar:0↦x}^{{evar:x↦0}})
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
      erewrite evar_quantify_evar_open; auto.
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (p0 $ AC.[□↦p])
Hwf: well_formed (ex , p) = true
IH2: Γ ⊢i p0 $ exists_quantify x AC.[□↦p^{evar:0↦x}] ---> p0 $ AC.[□↦ex , p]
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed
  (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed
  (exists_quantify x
     (p0 $ AC.[□↦p^{evar:0↦x}]))
Γ ⊢i AC.[□↦p]^{evar:0↦x} ---> (ex , AC.[□↦p])
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (p0 $ AC.[□↦p])
Hwf: well_formed (ex , p) = true
IH2: Γ
⊢i p0 $ exists_quantify x AC.[□↦p^{evar:0↦x}] --->
   p0 $ AC.[□↦ex , p]
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed
  (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed
  (exists_quantify x
     (p0 $ AC.[□↦p^{evar:0↦x}]))
well_formed_closed_ex_aux AC.[□↦p] 1
      2: now do 2 apply andb_true_iff in Hwfex as [_ Hwfex].
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (p0 $ AC.[□↦p])
Hwf: well_formed (ex , p) = true
IH2: Γ ⊢i p0 $ exists_quantify x AC.[□↦p^{evar:0↦x}] ---> p0 $ AC.[□↦ex , p]
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed
  (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed
  (exists_quantify x
     (p0 $ AC.[□↦p^{evar:0↦x}]))
Γ ⊢i AC.[□↦p]^{evar:0↦x} ---> (ex , AC.[□↦p])
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
      useBasicReasoning.
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (p0 $ AC.[□↦p])
Hwf: well_formed (ex , p) = true
IH2: Γ ⊢i p0 $ exists_quantify x AC.[□↦p^{evar:0↦x}] ---> p0 $ AC.[□↦ex , p]
using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed
  (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed
  (exists_quantify x
     (p0 $ AC.[□↦p^{evar:0↦x}]))
Γ ⊢i AC.[□↦p]^{evar:0↦x} ---> (ex , AC.[□↦p])
using BasicReasoning
      apply Ex_quan; auto.
      }
Defined.


Add Search Blacklist "_elim".
Add Search Blacklist "_graph_rect".
Add Search Blacklist "_graph_mut".
Add Search Blacklist "FunctionalElimination_".


Section FOL_helpers.

  Context {Σ : Signature}.

  (**
  NOTE: DO NOT REPLACE! The element variable in this function is 
  needed to substitute in such pattern context, which contain
  arbitrary patterns, but the path to the element variable
  is concrete. For example, in `⌈ E ⌉ $ φ` the path to `E` does
  not contain any ∃-s, thus no new variables need to be generated
  for `mlRewrite`.
  *)
  Fixpoint maximal_exists_depth_to (depth : nat) (E : evar) (ψ : Pattern) : nat :=
    match ψ with
    | patt_bott => 0
    | patt_sym _ => 0
    | patt_bound_evar _ => 0
    | patt_bound_svar _ => 0
    | patt_free_svar _ => 0
    | patt_free_evar E' =>
      match (decide (E' = E)) with
      | left _ => depth
      | right _ => 0
      end
    | patt_imp ψ₁ ψ₂
      => Nat.max
        (maximal_exists_depth_to depth E ψ₁)
        (maximal_exists_depth_to depth E ψ₂)
    | patt_app ψ₁ ψ₂
      => Nat.max
        (maximal_exists_depth_to depth E ψ₁)
        (maximal_exists_depth_to depth E ψ₂)
    | patt_exists ψ' => maximal_exists_depth_to (S depth) E ψ'
    | patt_mu ψ' => maximal_exists_depth_to depth E ψ'
    end.
  
  Lemma maximal_exists_depth_to_0 E ψ depth:
    E ∉ free_evars ψ ->
    maximal_exists_depth_to depth E ψ = 0.
Σ: Signature
E: evar
ψ: Pattern
depth: nat
E ∉ free_evars ψ
→ maximal_exists_depth_to depth E ψ = 0
  Proof.
Σ: Signature
E: evar
ψ: Pattern
depth: nat
E ∉ free_evars ψ
→ maximal_exists_depth_to depth E ψ = 0
    intros Hnotin.
Σ: Signature
E: evar
ψ: Pattern
depth: nat
Hnotin: E ∉ free_evars ψ
maximal_exists_depth_to depth E ψ = 0
    move: E depth Hnotin.
Σ: Signature
ψ: Pattern
∀ (E : evar) (depth : nat),
  E ∉ free_evars ψ
  → maximal_exists_depth_to depth E ψ = 0
    induction ψ; intros E depth Hnotin; simpl in *; try reflexivity.
Σ: Signature
x, E: evar
depth: nat
Hnotin: E ∉ {[x]}
(if decide (x = E) then depth else 0) = 0
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: ∀ (E : evar) (depth : nat),
  E ∉ free_evars ψ1
  → maximal_exists_depth_to depth E ψ1 = 0
IHψ2: ∀ (E : evar) (depth : nat),
  E ∉ free_evars ψ2
  → maximal_exists_depth_to depth E ψ2 = 0
E: evar
depth: nat
Hnotin: E ∉ free_evars ψ1 ∪ free_evars ψ2
maximal_exists_depth_to depth E ψ1
`max` maximal_exists_depth_to depth E ψ2 = 0
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: ∀ (E : evar) (depth : nat),
  E ∉ free_evars ψ1
  → maximal_exists_depth_to depth E ψ1 = 0
IHψ2: ∀ (E : evar) (depth : nat),
  E ∉ free_evars ψ2
  → maximal_exists_depth_to depth E ψ2 = 0
E: evar
depth: nat
Hnotin: E ∉ free_evars ψ1 ∪ free_evars ψ2
maximal_exists_depth_to depth E ψ1
`max` maximal_exists_depth_to depth E ψ2 = 0
Σ: Signature
ψ: Pattern
IHψ: ∀ (E : evar) (depth : nat),
  E ∉ free_evars ψ
  → maximal_exists_depth_to depth E ψ = 0
E: evar
depth: nat
Hnotin: E ∉ free_evars ψ
maximal_exists_depth_to (S depth) E ψ = 0
Σ: Signature
ψ: Pattern
IHψ: ∀ (E : evar) (depth : nat),
  E ∉ free_evars ψ
  → maximal_exists_depth_to depth E ψ = 0
E: evar
depth: nat
Hnotin: E ∉ free_evars ψ
maximal_exists_depth_to depth E ψ = 0
    {
Σ: Signature
x, E: evar
depth: nat
Hnotin: E ∉ {[x]}
(if decide (x = E) then depth else 0) = 0 case_match.
Σ: Signature
x, E: evar
depth: nat
Hnotin: E ∉ {[x]}
e: x = E
H: decide (x = E) = left e
depth = 0
Σ: Signature
x, E: evar
depth: nat
Hnotin: E ∉ {[x]}
n: x ≠ E
H: decide (x = E) = right n
0 = 0 set_solver.
Σ: Signature
x, E: evar
depth: nat
Hnotin: E ∉ {[x]}
n: x ≠ E
H: decide (x = E) = right n
0 = 0 reflexivity. }
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: ∀ (E : evar) (depth : nat),
  E ∉ free_evars ψ1
  → maximal_exists_depth_to depth E ψ1 = 0
IHψ2: ∀ (E : evar) (depth : nat),
  E ∉ free_evars ψ2
  → maximal_exists_depth_to depth E ψ2 = 0
E: evar
depth: nat
Hnotin: E ∉ free_evars ψ1 ∪ free_evars ψ2
maximal_exists_depth_to depth E ψ1
`max` maximal_exists_depth_to depth E ψ2 = 0
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: ∀ (E : evar) (depth : nat),
  E ∉ free_evars ψ1
  → maximal_exists_depth_to depth E ψ1 = 0
IHψ2: ∀ (E : evar) (depth : nat),
  E ∉ free_evars ψ2
  → maximal_exists_depth_to depth E ψ2 = 0
E: evar
depth: nat
Hnotin: E ∉ free_evars ψ1 ∪ free_evars ψ2
maximal_exists_depth_to depth E ψ1
`max` maximal_exists_depth_to depth E ψ2 = 0
Σ: Signature
ψ: Pattern
IHψ: ∀ (E : evar) (depth : nat),
  E ∉ free_evars ψ
  → maximal_exists_depth_to depth E ψ = 0
E: evar
depth: nat
Hnotin: E ∉ free_evars ψ
maximal_exists_depth_to (S depth) E ψ = 0
Σ: Signature
ψ: Pattern
IHψ: ∀ (E : evar) (depth : nat),
  E ∉ free_evars ψ
  → maximal_exists_depth_to depth E ψ = 0
E: evar
depth: nat
Hnotin: E ∉ free_evars ψ
maximal_exists_depth_to depth E ψ = 0
    {
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: ∀ (E : evar) (depth : nat),
  E ∉ free_evars ψ1
  → maximal_exists_depth_to depth E ψ1 = 0
IHψ2: ∀ (E : evar) (depth : nat),
  E ∉ free_evars ψ2
  → maximal_exists_depth_to depth E ψ2 = 0
E: evar
depth: nat
Hnotin: E ∉ free_evars ψ1 ∪ free_evars ψ2
maximal_exists_depth_to depth E ψ1
`max` maximal_exists_depth_to depth E ψ2 = 0 rewrite IHψ1.
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: ∀ (E : evar) (depth : nat),
  E ∉ free_evars ψ1
  → maximal_exists_depth_to depth E ψ1 = 0
IHψ2: ∀ (E : evar) (depth : nat),
  E ∉ free_evars ψ2
  → maximal_exists_depth_to depth E ψ2 = 0
E: evar
depth: nat
Hnotin: E ∉ free_evars ψ1 ∪ free_evars ψ2
E ∉ free_evars ψ1
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: ∀ (E : evar) (depth : nat),
  E ∉ free_evars ψ1
  → maximal_exists_depth_to depth E ψ1 = 0
IHψ2: ∀ (E : evar) (depth : nat),
  E ∉ free_evars ψ2
  → maximal_exists_depth_to depth E ψ2 = 0
E: evar
depth: nat
Hnotin: E ∉ free_evars ψ1 ∪ free_evars ψ2
0 `max` maximal_exists_depth_to depth E ψ2 = 0 set_solver.
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: ∀ (E : evar) (depth : nat),
  E ∉ free_evars ψ1
  → maximal_exists_depth_to depth E ψ1 = 0
IHψ2: ∀ (E : evar) (depth : nat),
  E ∉ free_evars ψ2
  → maximal_exists_depth_to depth E ψ2 = 0
E: evar
depth: nat
Hnotin: E ∉ free_evars ψ1 ∪ free_evars ψ2
0 `max` maximal_exists_depth_to depth E ψ2 = 0 rewrite IHψ2.
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: ∀ (E : evar) (depth : nat),
  E ∉ free_evars ψ1
  → maximal_exists_depth_to depth E ψ1 = 0
IHψ2: ∀ (E : evar) (depth : nat),
  E ∉ free_evars ψ2
  → maximal_exists_depth_to depth E ψ2 = 0
E: evar
depth: nat
Hnotin: E ∉ free_evars ψ1 ∪ free_evars ψ2
E ∉ free_evars ψ2
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: ∀ (E : evar) (depth : nat),
  E ∉ free_evars ψ1
  → maximal_exists_depth_to depth E ψ1 = 0
IHψ2: ∀ (E : evar) (depth : nat),
  E ∉ free_evars ψ2
  → maximal_exists_depth_to depth E ψ2 = 0
E: evar
depth: nat
Hnotin: E ∉ free_evars ψ1 ∪ free_evars ψ2
0 `max` 0 = 0 set_solver.
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: ∀ (E : evar) (depth : nat),
  E ∉ free_evars ψ1
  → maximal_exists_depth_to depth E ψ1 = 0
IHψ2: ∀ (E : evar) (depth : nat),
  E ∉ free_evars ψ2
  → maximal_exists_depth_to depth E ψ2 = 0
E: evar
depth: nat
Hnotin: E ∉ free_evars ψ1 ∪ free_evars ψ2
0 `max` 0 = 0 reflexivity. }
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: ∀ (E : evar) (depth : nat),
  E ∉ free_evars ψ1
  → maximal_exists_depth_to depth E ψ1 = 0
IHψ2: ∀ (E : evar) (depth : nat),
  E ∉ free_evars ψ2
  → maximal_exists_depth_to depth E ψ2 = 0
E: evar
depth: nat
Hnotin: E ∉ free_evars ψ1 ∪ free_evars ψ2
maximal_exists_depth_to depth E ψ1
`max` maximal_exists_depth_to depth E ψ2 = 0
Σ: Signature
ψ: Pattern
IHψ: ∀ (E : evar) (depth : nat),
  E ∉ free_evars ψ
  → maximal_exists_depth_to depth E ψ = 0
E: evar
depth: nat
Hnotin: E ∉ free_evars ψ
maximal_exists_depth_to (S depth) E ψ = 0
Σ: Signature
ψ: Pattern
IHψ: ∀ (E : evar) (depth : nat),
  E ∉ free_evars ψ
  → maximal_exists_depth_to depth E ψ = 0
E: evar
depth: nat
Hnotin: E ∉ free_evars ψ
maximal_exists_depth_to depth E ψ = 0
    {
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: ∀ (E : evar) (depth : nat),
  E ∉ free_evars ψ1
  → maximal_exists_depth_to depth E ψ1 = 0
IHψ2: ∀ (E : evar) (depth : nat),
  E ∉ free_evars ψ2
  → maximal_exists_depth_to depth E ψ2 = 0
E: evar
depth: nat
Hnotin: E ∉ free_evars ψ1 ∪ free_evars ψ2
maximal_exists_depth_to depth E ψ1
`max` maximal_exists_depth_to depth E ψ2 = 0 rewrite IHψ1.
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: ∀ (E : evar) (depth : nat),
  E ∉ free_evars ψ1
  → maximal_exists_depth_to depth E ψ1 = 0
IHψ2: ∀ (E : evar) (depth : nat),
  E ∉ free_evars ψ2
  → maximal_exists_depth_to depth E ψ2 = 0
E: evar
depth: nat
Hnotin: E ∉ free_evars ψ1 ∪ free_evars ψ2
E ∉ free_evars ψ1
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: ∀ (E : evar) (depth : nat),
  E ∉ free_evars ψ1
  → maximal_exists_depth_to depth E ψ1 = 0
IHψ2: ∀ (E : evar) (depth : nat),
  E ∉ free_evars ψ2
  → maximal_exists_depth_to depth E ψ2 = 0
E: evar
depth: nat
Hnotin: E ∉ free_evars ψ1 ∪ free_evars ψ2
0 `max` maximal_exists_depth_to depth E ψ2 = 0 set_solver.
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: ∀ (E : evar) (depth : nat),
  E ∉ free_evars ψ1
  → maximal_exists_depth_to depth E ψ1 = 0
IHψ2: ∀ (E : evar) (depth : nat),
  E ∉ free_evars ψ2
  → maximal_exists_depth_to depth E ψ2 = 0
E: evar
depth: nat
Hnotin: E ∉ free_evars ψ1 ∪ free_evars ψ2
0 `max` maximal_exists_depth_to depth E ψ2 = 0 rewrite IHψ2.
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: ∀ (E : evar) (depth : nat),
  E ∉ free_evars ψ1
  → maximal_exists_depth_to depth E ψ1 = 0
IHψ2: ∀ (E : evar) (depth : nat),
  E ∉ free_evars ψ2
  → maximal_exists_depth_to depth E ψ2 = 0
E: evar
depth: nat
Hnotin: E ∉ free_evars ψ1 ∪ free_evars ψ2
E ∉ free_evars ψ2
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: ∀ (E : evar) (depth : nat),
  E ∉ free_evars ψ1
  → maximal_exists_depth_to depth E ψ1 = 0
IHψ2: ∀ (E : evar) (depth : nat),
  E ∉ free_evars ψ2
  → maximal_exists_depth_to depth E ψ2 = 0
E: evar
depth: nat
Hnotin: E ∉ free_evars ψ1 ∪ free_evars ψ2
0 `max` 0 = 0 set_solver.
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: ∀ (E : evar) (depth : nat),
  E ∉ free_evars ψ1
  → maximal_exists_depth_to depth E ψ1 = 0
IHψ2: ∀ (E : evar) (depth : nat),
  E ∉ free_evars ψ2
  → maximal_exists_depth_to depth E ψ2 = 0
E: evar
depth: nat
Hnotin: E ∉ free_evars ψ1 ∪ free_evars ψ2
0 `max` 0 = 0 reflexivity. }
Σ: Signature
ψ: Pattern
IHψ: ∀ (E : evar) (depth : nat),
E ∉ free_evars ψ → maximal_exists_depth_to depth E ψ = 0
E: evar
depth: nat
Hnotin: E ∉ free_evars ψ
maximal_exists_depth_to (S depth) E ψ = 0
Σ: Signature
ψ: Pattern
IHψ: ∀ (E : evar) (depth : nat),
  E ∉ free_evars ψ
  → maximal_exists_depth_to depth E ψ = 0
E: evar
depth: nat
Hnotin: E ∉ free_evars ψ
maximal_exists_depth_to depth E ψ = 0
    {
Σ: Signature
ψ: Pattern
IHψ: ∀ (E : evar) (depth : nat),
E ∉ free_evars ψ → maximal_exists_depth_to depth E ψ = 0
E: evar
depth: nat
Hnotin: E ∉ free_evars ψ
maximal_exists_depth_to (S depth) E ψ = 0 rewrite IHψ.
Σ: Signature
ψ: Pattern
IHψ: ∀ (E : evar) (depth : nat),
E ∉ free_evars ψ → maximal_exists_depth_to depth E ψ = 0
E: evar
depth: nat
Hnotin: E ∉ free_evars ψ
E ∉ free_evars ψ
Σ: Signature
ψ: Pattern
IHψ: ∀ (E : evar) (depth : nat),
  E ∉ free_evars ψ
  → maximal_exists_depth_to depth E ψ = 0
E: evar
depth: nat
Hnotin: E ∉ free_evars ψ
0 = 0 exact Hnotin.
Σ: Signature
ψ: Pattern
IHψ: ∀ (E : evar) (depth : nat),
E ∉ free_evars ψ → maximal_exists_depth_to depth E ψ = 0
E: evar
depth: nat
Hnotin: E ∉ free_evars ψ
0 = 0 reflexivity. }
Σ: Signature
ψ: Pattern
IHψ: ∀ (E : evar) (depth : nat),
E ∉ free_evars ψ → maximal_exists_depth_to depth E ψ = 0
E: evar
depth: nat
Hnotin: E ∉ free_evars ψ
maximal_exists_depth_to depth E ψ = 0
    {
Σ: Signature
ψ: Pattern
IHψ: ∀ (E : evar) (depth : nat),
E ∉ free_evars ψ → maximal_exists_depth_to depth E ψ = 0
E: evar
depth: nat
Hnotin: E ∉ free_evars ψ
maximal_exists_depth_to depth E ψ = 0 rewrite IHψ.
Σ: Signature
ψ: Pattern
IHψ: ∀ (E : evar) (depth : nat),
E ∉ free_evars ψ → maximal_exists_depth_to depth E ψ = 0
E: evar
depth: nat
Hnotin: E ∉ free_evars ψ
E ∉ free_evars ψ
Σ: Signature
ψ: Pattern
IHψ: ∀ (E : evar) (depth : nat),
  E ∉ free_evars ψ
  → maximal_exists_depth_to depth E ψ = 0
E: evar
depth: nat
Hnotin: E ∉ free_evars ψ
0 = 0 exact Hnotin.
Σ: Signature
ψ: Pattern
IHψ: ∀ (E : evar) (depth : nat),
E ∉ free_evars ψ → maximal_exists_depth_to depth E ψ = 0
E: evar
depth: nat
Hnotin: E ∉ free_evars ψ
0 = 0 reflexivity. }
  Qed.

  Lemma maximal_exists_depth_to_S E ψ depth:
    E ∈ free_evars ψ ->
    maximal_exists_depth_to (S depth) E ψ
    = S (maximal_exists_depth_to depth E ψ).
Σ: Signature
E: evar
ψ: Pattern
depth: nat
E ∈ free_evars ψ
→ maximal_exists_depth_to (S depth) E ψ =
  S (maximal_exists_depth_to depth E ψ)
  Proof.
Σ: Signature
E: evar
ψ: Pattern
depth: nat
E ∈ free_evars ψ
→ maximal_exists_depth_to (S depth) E ψ =
  S (maximal_exists_depth_to depth E ψ)
    intros Hin.
Σ: Signature
E: evar
ψ: Pattern
depth: nat
Hin: E ∈ free_evars ψ
maximal_exists_depth_to (S depth) E ψ =
S (maximal_exists_depth_to depth E ψ)
    move: E depth Hin.
Σ: Signature
ψ: Pattern
∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ
  → maximal_exists_depth_to (S depth) E ψ =
    S (maximal_exists_depth_to depth E ψ)
    induction ψ; intros E depth Hin; simpl in *; try set_solver.
Σ: Signature
x, E: evar
depth: nat
Hin: E ∈ {[x]}
(if decide (x = E) then S depth else 0) =
S (if decide (x = E) then depth else 0)
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ1
  → maximal_exists_depth_to (S depth) E ψ1 =
    S (maximal_exists_depth_to depth E ψ1)
IHψ2: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ2
  → maximal_exists_depth_to (S depth) E ψ2 =
    S (maximal_exists_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
maximal_exists_depth_to (S depth) E ψ1
`max` maximal_exists_depth_to (S depth) E ψ2 =
S
  (maximal_exists_depth_to depth E ψ1
   `max` maximal_exists_depth_to depth E ψ2)
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ1
  → maximal_exists_depth_to (S depth) E ψ1 =
    S (maximal_exists_depth_to depth E ψ1)
IHψ2: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ2
  → maximal_exists_depth_to (S depth) E ψ2 =
    S (maximal_exists_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
maximal_exists_depth_to (S depth) E ψ1
`max` maximal_exists_depth_to (S depth) E ψ2 =
S
  (maximal_exists_depth_to depth E ψ1
   `max` maximal_exists_depth_to depth E ψ2)
    {
Σ: Signature
x, E: evar
depth: nat
Hin: E ∈ {[x]}
(if decide (x = E) then S depth else 0) =
S (if decide (x = E) then depth else 0) case_match.
Σ: Signature
x, E: evar
depth: nat
Hin: E ∈ {[x]}
e: x = E
H: decide (x = E) = left e
S depth = S depth
Σ: Signature
x, E: evar
depth: nat
Hin: E ∈ {[x]}
n: x ≠ E
H: decide (x = E) = right n
0 = 1 reflexivity.
Σ: Signature
x, E: evar
depth: nat
Hin: E ∈ {[x]}
n: x ≠ E
H: decide (x = E) = right n
0 = 1 set_solver. }
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ1
  → maximal_exists_depth_to (S depth) E ψ1 =
    S (maximal_exists_depth_to depth E ψ1)
IHψ2: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ2
  → maximal_exists_depth_to (S depth) E ψ2 =
    S (maximal_exists_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
maximal_exists_depth_to (S depth) E ψ1
`max` maximal_exists_depth_to (S depth) E ψ2 =
S
  (maximal_exists_depth_to depth E ψ1
   `max` maximal_exists_depth_to depth E ψ2)
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ1
  → maximal_exists_depth_to (S depth) E ψ1 =
    S (maximal_exists_depth_to depth E ψ1)
IHψ2: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ2
  → maximal_exists_depth_to (S depth) E ψ2 =
    S (maximal_exists_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
maximal_exists_depth_to (S depth) E ψ1
`max` maximal_exists_depth_to (S depth) E ψ2 =
S
  (maximal_exists_depth_to depth E ψ1
   `max` maximal_exists_depth_to depth E ψ2)
    {
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ1
  → maximal_exists_depth_to (S depth) E ψ1 =
    S (maximal_exists_depth_to depth E ψ1)
IHψ2: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ2
  → maximal_exists_depth_to (S depth) E ψ2 =
    S (maximal_exists_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
maximal_exists_depth_to (S depth) E ψ1
`max` maximal_exists_depth_to (S depth) E ψ2 =
S
  (maximal_exists_depth_to depth E ψ1
   `max` maximal_exists_depth_to depth E ψ2)
      destruct (decide (E ∈ free_evars ψ1)),(decide (E ∈ free_evars ψ2)).
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ1
  → maximal_exists_depth_to (S depth) E ψ1 =
    S (maximal_exists_depth_to depth E ψ1)
IHψ2: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ2
  → maximal_exists_depth_to (S depth) E ψ2 =
    S (maximal_exists_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
e: E ∈ free_evars ψ1
e0: E ∈ free_evars ψ2
maximal_exists_depth_to (S depth) E ψ1
`max` maximal_exists_depth_to (S depth) E ψ2 =
S
  (maximal_exists_depth_to depth E ψ1
   `max` maximal_exists_depth_to depth E ψ2)
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ1
  → maximal_exists_depth_to (S depth) E ψ1 =
    S (maximal_exists_depth_to depth E ψ1)
IHψ2: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ2
  → maximal_exists_depth_to (S depth) E ψ2 =
    S (maximal_exists_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
e: E ∈ free_evars ψ1
n: E ∉ free_evars ψ2
maximal_exists_depth_to (S depth) E ψ1
`max` maximal_exists_depth_to (S depth) E ψ2 =
S
  (maximal_exists_depth_to depth E ψ1
   `max` maximal_exists_depth_to depth E ψ2)
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ1
  → maximal_exists_depth_to (S depth) E ψ1 =
    S (maximal_exists_depth_to depth E ψ1)
IHψ2: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ2
  → maximal_exists_depth_to (S depth) E ψ2 =
    S (maximal_exists_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
n: E ∉ free_evars ψ1
e: E ∈ free_evars ψ2
maximal_exists_depth_to (S depth) E ψ1
`max` maximal_exists_depth_to (S depth) E ψ2 =
S
  (maximal_exists_depth_to depth E ψ1
   `max` maximal_exists_depth_to depth E ψ2)
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ1
  → maximal_exists_depth_to (S depth) E ψ1 =
    S (maximal_exists_depth_to depth E ψ1)
IHψ2: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ2
  → maximal_exists_depth_to (S depth) E ψ2 =
    S (maximal_exists_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
n: E ∉ free_evars ψ1
n0: E ∉ free_evars ψ2
maximal_exists_depth_to (S depth) E ψ1
`max` maximal_exists_depth_to (S depth) E ψ2 =
S
  (maximal_exists_depth_to depth E ψ1
   `max` maximal_exists_depth_to depth E ψ2)
      {
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ1
  → maximal_exists_depth_to (S depth) E ψ1 =
    S (maximal_exists_depth_to depth E ψ1)
IHψ2: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ2
  → maximal_exists_depth_to (S depth) E ψ2 =
    S (maximal_exists_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
e: E ∈ free_evars ψ1
e0: E ∈ free_evars ψ2
maximal_exists_depth_to (S depth) E ψ1
`max` maximal_exists_depth_to (S depth) E ψ2 =
S
  (maximal_exists_depth_to depth E ψ1
   `max` maximal_exists_depth_to depth E ψ2)
        rewrite IHψ1.
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ1
  → maximal_exists_depth_to (S depth) E ψ1 =
    S (maximal_exists_depth_to depth E ψ1)
IHψ2: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ2
  → maximal_exists_depth_to (S depth) E ψ2 =
    S (maximal_exists_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
e: E ∈ free_evars ψ1
e0: E ∈ free_evars ψ2
E ∈ free_evars ψ1
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ1
  → maximal_exists_depth_to (S depth) E ψ1 =
    S (maximal_exists_depth_to depth E ψ1)
IHψ2: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ2
  → maximal_exists_depth_to (S depth) E ψ2 =
    S (maximal_exists_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
e: E ∈ free_evars ψ1
e0: E ∈ free_evars ψ2
S (maximal_exists_depth_to depth E ψ1)
`max` maximal_exists_depth_to (S depth) E ψ2 =
S
  (maximal_exists_depth_to depth E ψ1
   `max` maximal_exists_depth_to depth E ψ2) assumption.
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ1
  → maximal_exists_depth_to (S depth) E ψ1 =
    S (maximal_exists_depth_to depth E ψ1)
IHψ2: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ2
  → maximal_exists_depth_to (S depth) E ψ2 =
    S (maximal_exists_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
e: E ∈ free_evars ψ1
e0: E ∈ free_evars ψ2
S (maximal_exists_depth_to depth E ψ1)
`max` maximal_exists_depth_to (S depth) E ψ2 =
S
  (maximal_exists_depth_to depth E ψ1
   `max` maximal_exists_depth_to depth E ψ2) rewrite IHψ2.
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ1
  → maximal_exists_depth_to (S depth) E ψ1 =
    S (maximal_exists_depth_to depth E ψ1)
IHψ2: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ2
  → maximal_exists_depth_to (S depth) E ψ2 =
    S (maximal_exists_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
e: E ∈ free_evars ψ1
e0: E ∈ free_evars ψ2
E ∈ free_evars ψ2
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ1
  → maximal_exists_depth_to (S depth) E ψ1 =
    S (maximal_exists_depth_to depth E ψ1)
IHψ2: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ2
  → maximal_exists_depth_to (S depth) E ψ2 =
    S (maximal_exists_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
e: E ∈ free_evars ψ1
e0: E ∈ free_evars ψ2
S (maximal_exists_depth_to depth E ψ1)
`max` S (maximal_exists_depth_to depth E ψ2) =
S
  (maximal_exists_depth_to depth E ψ1
   `max` maximal_exists_depth_to depth E ψ2) assumption.
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ1
  → maximal_exists_depth_to (S depth) E ψ1 =
    S (maximal_exists_depth_to depth E ψ1)
IHψ2: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ2
  → maximal_exists_depth_to (S depth) E ψ2 =
    S (maximal_exists_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
e: E ∈ free_evars ψ1
e0: E ∈ free_evars ψ2
S (maximal_exists_depth_to depth E ψ1)
`max` S (maximal_exists_depth_to depth E ψ2) =
S
  (maximal_exists_depth_to depth E ψ1
   `max` maximal_exists_depth_to depth E ψ2) simpl.
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ1
  → maximal_exists_depth_to (S depth) E ψ1 =
    S (maximal_exists_depth_to depth E ψ1)
IHψ2: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ2
  → maximal_exists_depth_to (S depth) E ψ2 =
    S (maximal_exists_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
e: E ∈ free_evars ψ1
e0: E ∈ free_evars ψ2
S
  (maximal_exists_depth_to depth E ψ1
   `max` maximal_exists_depth_to depth E ψ2) =
S
  (maximal_exists_depth_to depth E ψ1
   `max` maximal_exists_depth_to depth E ψ2) reflexivity.
      }
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ1
  → maximal_exists_depth_to (S depth) E ψ1 =
    S (maximal_exists_depth_to depth E ψ1)
IHψ2: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ2
  → maximal_exists_depth_to (S depth) E ψ2 =
    S (maximal_exists_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
e: E ∈ free_evars ψ1
n: E ∉ free_evars ψ2
maximal_exists_depth_to (S depth) E ψ1
`max` maximal_exists_depth_to (S depth) E ψ2 =
S
  (maximal_exists_depth_to depth E ψ1
   `max` maximal_exists_depth_to depth E ψ2)
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ1
  → maximal_exists_depth_to (S depth) E ψ1 =
    S (maximal_exists_depth_to depth E ψ1)
IHψ2: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ2
  → maximal_exists_depth_to (S depth) E ψ2 =
    S (maximal_exists_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
n: E ∉ free_evars ψ1
e: E ∈ free_evars ψ2
maximal_exists_depth_to (S depth) E ψ1
`max` maximal_exists_depth_to (S depth) E ψ2 =
S
  (maximal_exists_depth_to depth E ψ1
   `max` maximal_exists_depth_to depth E ψ2)
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ1
  → maximal_exists_depth_to (S depth) E ψ1 =
    S (maximal_exists_depth_to depth E ψ1)
IHψ2: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ2
  → maximal_exists_depth_to (S depth) E ψ2 =
    S (maximal_exists_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
n: E ∉ free_evars ψ1
n0: E ∉ free_evars ψ2
maximal_exists_depth_to (S depth) E ψ1
`max` maximal_exists_depth_to (S depth) E ψ2 =
S
  (maximal_exists_depth_to depth E ψ1
   `max` maximal_exists_depth_to depth E ψ2)
      {
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ1
  → maximal_exists_depth_to (S depth) E ψ1 =
    S (maximal_exists_depth_to depth E ψ1)
IHψ2: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ2
  → maximal_exists_depth_to (S depth) E ψ2 =
    S (maximal_exists_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
e: E ∈ free_evars ψ1
n: E ∉ free_evars ψ2
maximal_exists_depth_to (S depth) E ψ1
`max` maximal_exists_depth_to (S depth) E ψ2 =
S
  (maximal_exists_depth_to depth E ψ1
   `max` maximal_exists_depth_to depth E ψ2)
        rewrite IHψ1.
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ1
  → maximal_exists_depth_to (S depth) E ψ1 =
    S (maximal_exists_depth_to depth E ψ1)
IHψ2: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ2
  → maximal_exists_depth_to (S depth) E ψ2 =
    S (maximal_exists_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
e: E ∈ free_evars ψ1
n: E ∉ free_evars ψ2
E ∈ free_evars ψ1
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ1
  → maximal_exists_depth_to (S depth) E ψ1 =
    S (maximal_exists_depth_to depth E ψ1)
IHψ2: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ2
  → maximal_exists_depth_to (S depth) E ψ2 =
    S (maximal_exists_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
e: E ∈ free_evars ψ1
n: E ∉ free_evars ψ2
S (maximal_exists_depth_to depth E ψ1)
`max` maximal_exists_depth_to (S depth) E ψ2 =
S
  (maximal_exists_depth_to depth E ψ1
   `max` maximal_exists_depth_to depth E ψ2) assumption.
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ1
  → maximal_exists_depth_to (S depth) E ψ1 =
    S (maximal_exists_depth_to depth E ψ1)
IHψ2: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ2
  → maximal_exists_depth_to (S depth) E ψ2 =
    S (maximal_exists_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
e: E ∈ free_evars ψ1
n: E ∉ free_evars ψ2
S (maximal_exists_depth_to depth E ψ1)
`max` maximal_exists_depth_to (S depth) E ψ2 =
S
  (maximal_exists_depth_to depth E ψ1
   `max` maximal_exists_depth_to depth E ψ2)
        apply maximal_exists_depth_to_0 with (depth := S depth) in n
          as n'.
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ1
  → maximal_exists_depth_to (S depth) E ψ1 =
    S (maximal_exists_depth_to depth E ψ1)
IHψ2: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ2
  → maximal_exists_depth_to (S depth) E ψ2 =
    S (maximal_exists_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
e: E ∈ free_evars ψ1
n: E ∉ free_evars ψ2
n': maximal_exists_depth_to (S depth) E ψ2 = 0
S (maximal_exists_depth_to depth E ψ1)
`max` maximal_exists_depth_to (S depth) E ψ2 =
S
  (maximal_exists_depth_to depth E ψ1
   `max` maximal_exists_depth_to depth E ψ2)
        apply maximal_exists_depth_to_0 with (depth := depth) in n.
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ1
  → maximal_exists_depth_to (S depth) E ψ1 =
    S (maximal_exists_depth_to depth E ψ1)
IHψ2: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ2
  → maximal_exists_depth_to (S depth) E ψ2 =
    S (maximal_exists_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
e: E ∈ free_evars ψ1
n: maximal_exists_depth_to depth E ψ2 = 0
n': maximal_exists_depth_to (S depth) E ψ2 = 0
S (maximal_exists_depth_to depth E ψ1)
`max` maximal_exists_depth_to (S depth) E ψ2 =
S
  (maximal_exists_depth_to depth E ψ1
   `max` maximal_exists_depth_to depth E ψ2)
        rewrite n.
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ1
  → maximal_exists_depth_to (S depth) E ψ1 =
    S (maximal_exists_depth_to depth E ψ1)
IHψ2: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ2
  → maximal_exists_depth_to (S depth) E ψ2 =
    S (maximal_exists_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
e: E ∈ free_evars ψ1
n: maximal_exists_depth_to depth E ψ2 = 0
n': maximal_exists_depth_to (S depth) E ψ2 = 0
S (maximal_exists_depth_to depth E ψ1)
`max` maximal_exists_depth_to (S depth) E ψ2 =
S (maximal_exists_depth_to depth E ψ1 `max` 0) lia. 
      }
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ1
  → maximal_exists_depth_to (S depth) E ψ1 =
    S (maximal_exists_depth_to depth E ψ1)
IHψ2: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ2
  → maximal_exists_depth_to (S depth) E ψ2 =
    S (maximal_exists_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
n: E ∉ free_evars ψ1
e: E ∈ free_evars ψ2
maximal_exists_depth_to (S depth) E ψ1
`max` maximal_exists_depth_to (S depth) E ψ2 =
S
  (maximal_exists_depth_to depth E ψ1
   `max` maximal_exists_depth_to depth E ψ2)
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ1
  → maximal_exists_depth_to (S depth) E ψ1 =
    S (maximal_exists_depth_to depth E ψ1)
IHψ2: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ2
  → maximal_exists_depth_to (S depth) E ψ2 =
    S (maximal_exists_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
n: E ∉ free_evars ψ1
n0: E ∉ free_evars ψ2
maximal_exists_depth_to (S depth) E ψ1
`max` maximal_exists_depth_to (S depth) E ψ2 =
S
  (maximal_exists_depth_to depth E ψ1
   `max` maximal_exists_depth_to depth E ψ2)
      {
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ1
  → maximal_exists_depth_to (S depth) E ψ1 =
    S (maximal_exists_depth_to depth E ψ1)
IHψ2: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ2
  → maximal_exists_depth_to (S depth) E ψ2 =
    S (maximal_exists_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
n: E ∉ free_evars ψ1
e: E ∈ free_evars ψ2
maximal_exists_depth_to (S depth) E ψ1
`max` maximal_exists_depth_to (S depth) E ψ2 =
S
  (maximal_exists_depth_to depth E ψ1
   `max` maximal_exists_depth_to depth E ψ2)
        rewrite IHψ2.
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ1
  → maximal_exists_depth_to (S depth) E ψ1 =
    S (maximal_exists_depth_to depth E ψ1)
IHψ2: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ2
  → maximal_exists_depth_to (S depth) E ψ2 =
    S (maximal_exists_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
n: E ∉ free_evars ψ1
e: E ∈ free_evars ψ2
E ∈ free_evars ψ2
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ1
  → maximal_exists_depth_to (S depth) E ψ1 =
    S (maximal_exists_depth_to depth E ψ1)
IHψ2: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ2
  → maximal_exists_depth_to (S depth) E ψ2 =
    S (maximal_exists_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
n: E ∉ free_evars ψ1
e: E ∈ free_evars ψ2
maximal_exists_depth_to (S depth) E ψ1
`max` S (maximal_exists_depth_to depth E ψ2) =
S
  (maximal_exists_depth_to depth E ψ1
   `max` maximal_exists_depth_to depth E ψ2) assumption.
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ1
  → maximal_exists_depth_to (S depth) E ψ1 =
    S (maximal_exists_depth_to depth E ψ1)
IHψ2: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ2
  → maximal_exists_depth_to (S depth) E ψ2 =
    S (maximal_exists_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
n: E ∉ free_evars ψ1
e: E ∈ free_evars ψ2
maximal_exists_depth_to (S depth) E ψ1
`max` S (maximal_exists_depth_to depth E ψ2) =
S
  (maximal_exists_depth_to depth E ψ1
   `max` maximal_exists_depth_to depth E ψ2)
        apply maximal_exists_depth_to_0 with (depth := S depth) in n
          as n'.
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ1
  → maximal_exists_depth_to (S depth) E ψ1 =
    S (maximal_exists_depth_to depth E ψ1)
IHψ2: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ2
  → maximal_exists_depth_to (S depth) E ψ2 =
    S (maximal_exists_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
n: E ∉ free_evars ψ1
e: E ∈ free_evars ψ2
n': maximal_exists_depth_to (S depth) E ψ1 = 0
maximal_exists_depth_to (S depth) E ψ1
`max` S (maximal_exists_depth_to depth E ψ2) =
S
  (maximal_exists_depth_to depth E ψ1
   `max` maximal_exists_depth_to depth E ψ2)
        apply maximal_exists_depth_to_0 with (depth := depth) in n.
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ1
  → maximal_exists_depth_to (S depth) E ψ1 =
    S (maximal_exists_depth_to depth E ψ1)
IHψ2: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ2
  → maximal_exists_depth_to (S depth) E ψ2 =
    S (maximal_exists_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
n: maximal_exists_depth_to depth E ψ1 = 0
e: E ∈ free_evars ψ2
n': maximal_exists_depth_to (S depth) E ψ1 = 0
maximal_exists_depth_to (S depth) E ψ1
`max` S (maximal_exists_depth_to depth E ψ2) =
S
  (maximal_exists_depth_to depth E ψ1
   `max` maximal_exists_depth_to depth E ψ2)
        rewrite n.
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ1
  → maximal_exists_depth_to (S depth) E ψ1 =
    S (maximal_exists_depth_to depth E ψ1)
IHψ2: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ2
  → maximal_exists_depth_to (S depth) E ψ2 =
    S (maximal_exists_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
n: maximal_exists_depth_to depth E ψ1 = 0
e: E ∈ free_evars ψ2
n': maximal_exists_depth_to (S depth) E ψ1 = 0
maximal_exists_depth_to (S depth) E ψ1
`max` S (maximal_exists_depth_to depth E ψ2) =
S (0 `max` maximal_exists_depth_to depth E ψ2) lia. 
      }
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ1
  → maximal_exists_depth_to (S depth) E ψ1 =
    S (maximal_exists_depth_to depth E ψ1)
IHψ2: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ2
  → maximal_exists_depth_to (S depth) E ψ2 =
    S (maximal_exists_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
n: E ∉ free_evars ψ1
n0: E ∉ free_evars ψ2
maximal_exists_depth_to (S depth) E ψ1
`max` maximal_exists_depth_to (S depth) E ψ2 =
S
  (maximal_exists_depth_to depth E ψ1
   `max` maximal_exists_depth_to depth E ψ2)
      {
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ1
  → maximal_exists_depth_to (S depth) E ψ1 =
    S (maximal_exists_depth_to depth E ψ1)
IHψ2: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ2
  → maximal_exists_depth_to (S depth) E ψ2 =
    S (maximal_exists_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
n: E ∉ free_evars ψ1
n0: E ∉ free_evars ψ2
maximal_exists_depth_to (S depth) E ψ1
`max` maximal_exists_depth_to (S depth) E ψ2 =
S
  (maximal_exists_depth_to depth E ψ1
   `max` maximal_exists_depth_to depth E ψ2)
        exfalso.
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ1
  → maximal_exists_depth_to (S depth) E ψ1 =
    S (maximal_exists_depth_to depth E ψ1)
IHψ2: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ2
  → maximal_exists_depth_to (S depth) E ψ2 =
    S (maximal_exists_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
n: E ∉ free_evars ψ1
n0: E ∉ free_evars ψ2
False set_solver.
      }
    }
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ1
  → maximal_exists_depth_to (S depth) E ψ1 =
    S (maximal_exists_depth_to depth E ψ1)
IHψ2: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ2
  → maximal_exists_depth_to (S depth) E ψ2 =
    S (maximal_exists_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
maximal_exists_depth_to (S depth) E ψ1
`max` maximal_exists_depth_to (S depth) E ψ2 =
S
  (maximal_exists_depth_to depth E ψ1
   `max` maximal_exists_depth_to depth E ψ2)
    {
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ1
  → maximal_exists_depth_to (S depth) E ψ1 =
    S (maximal_exists_depth_to depth E ψ1)
IHψ2: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ2
  → maximal_exists_depth_to (S depth) E ψ2 =
    S (maximal_exists_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
maximal_exists_depth_to (S depth) E ψ1
`max` maximal_exists_depth_to (S depth) E ψ2 =
S
  (maximal_exists_depth_to depth E ψ1
   `max` maximal_exists_depth_to depth E ψ2)
      destruct (decide (E ∈ free_evars ψ1)),(decide (E ∈ free_evars ψ2)).
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ1
  → maximal_exists_depth_to (S depth) E ψ1 =
    S (maximal_exists_depth_to depth E ψ1)
IHψ2: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ2
  → maximal_exists_depth_to (S depth) E ψ2 =
    S (maximal_exists_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
e: E ∈ free_evars ψ1
e0: E ∈ free_evars ψ2
maximal_exists_depth_to (S depth) E ψ1
`max` maximal_exists_depth_to (S depth) E ψ2 =
S
  (maximal_exists_depth_to depth E ψ1
   `max` maximal_exists_depth_to depth E ψ2)
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ1
  → maximal_exists_depth_to (S depth) E ψ1 =
    S (maximal_exists_depth_to depth E ψ1)
IHψ2: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ2
  → maximal_exists_depth_to (S depth) E ψ2 =
    S (maximal_exists_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
e: E ∈ free_evars ψ1
n: E ∉ free_evars ψ2
maximal_exists_depth_to (S depth) E ψ1
`max` maximal_exists_depth_to (S depth) E ψ2 =
S
  (maximal_exists_depth_to depth E ψ1
   `max` maximal_exists_depth_to depth E ψ2)
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ1
  → maximal_exists_depth_to (S depth) E ψ1 =
    S (maximal_exists_depth_to depth E ψ1)
IHψ2: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ2
  → maximal_exists_depth_to (S depth) E ψ2 =
    S (maximal_exists_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
n: E ∉ free_evars ψ1
e: E ∈ free_evars ψ2
maximal_exists_depth_to (S depth) E ψ1
`max` maximal_exists_depth_to (S depth) E ψ2 =
S
  (maximal_exists_depth_to depth E ψ1
   `max` maximal_exists_depth_to depth E ψ2)
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ1
  → maximal_exists_depth_to (S depth) E ψ1 =
    S (maximal_exists_depth_to depth E ψ1)
IHψ2: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ2
  → maximal_exists_depth_to (S depth) E ψ2 =
    S (maximal_exists_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
n: E ∉ free_evars ψ1
n0: E ∉ free_evars ψ2
maximal_exists_depth_to (S depth) E ψ1
`max` maximal_exists_depth_to (S depth) E ψ2 =
S
  (maximal_exists_depth_to depth E ψ1
   `max` maximal_exists_depth_to depth E ψ2)
      {
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ1
  → maximal_exists_depth_to (S depth) E ψ1 =
    S (maximal_exists_depth_to depth E ψ1)
IHψ2: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ2
  → maximal_exists_depth_to (S depth) E ψ2 =
    S (maximal_exists_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
e: E ∈ free_evars ψ1
e0: E ∈ free_evars ψ2
maximal_exists_depth_to (S depth) E ψ1
`max` maximal_exists_depth_to (S depth) E ψ2 =
S
  (maximal_exists_depth_to depth E ψ1
   `max` maximal_exists_depth_to depth E ψ2)
        rewrite IHψ1.
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ1
  → maximal_exists_depth_to (S depth) E ψ1 =
    S (maximal_exists_depth_to depth E ψ1)
IHψ2: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ2
  → maximal_exists_depth_to (S depth) E ψ2 =
    S (maximal_exists_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
e: E ∈ free_evars ψ1
e0: E ∈ free_evars ψ2
E ∈ free_evars ψ1
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ1
  → maximal_exists_depth_to (S depth) E ψ1 =
    S (maximal_exists_depth_to depth E ψ1)
IHψ2: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ2
  → maximal_exists_depth_to (S depth) E ψ2 =
    S (maximal_exists_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
e: E ∈ free_evars ψ1
e0: E ∈ free_evars ψ2
S (maximal_exists_depth_to depth E ψ1)
`max` maximal_exists_depth_to (S depth) E ψ2 =
S
  (maximal_exists_depth_to depth E ψ1
   `max` maximal_exists_depth_to depth E ψ2) assumption.
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ1
  → maximal_exists_depth_to (S depth) E ψ1 =
    S (maximal_exists_depth_to depth E ψ1)
IHψ2: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ2
  → maximal_exists_depth_to (S depth) E ψ2 =
    S (maximal_exists_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
e: E ∈ free_evars ψ1
e0: E ∈ free_evars ψ2
S (maximal_exists_depth_to depth E ψ1)
`max` maximal_exists_depth_to (S depth) E ψ2 =
S
  (maximal_exists_depth_to depth E ψ1
   `max` maximal_exists_depth_to depth E ψ2) rewrite IHψ2.
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ1
  → maximal_exists_depth_to (S depth) E ψ1 =
    S (maximal_exists_depth_to depth E ψ1)
IHψ2: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ2
  → maximal_exists_depth_to (S depth) E ψ2 =
    S (maximal_exists_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
e: E ∈ free_evars ψ1
e0: E ∈ free_evars ψ2
E ∈ free_evars ψ2
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ1
  → maximal_exists_depth_to (S depth) E ψ1 =
    S (maximal_exists_depth_to depth E ψ1)
IHψ2: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ2
  → maximal_exists_depth_to (S depth) E ψ2 =
    S (maximal_exists_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
e: E ∈ free_evars ψ1
e0: E ∈ free_evars ψ2
S (maximal_exists_depth_to depth E ψ1)
`max` S (maximal_exists_depth_to depth E ψ2) =
S
  (maximal_exists_depth_to depth E ψ1
   `max` maximal_exists_depth_to depth E ψ2) assumption.
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ1
  → maximal_exists_depth_to (S depth) E ψ1 =
    S (maximal_exists_depth_to depth E ψ1)
IHψ2: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ2
  → maximal_exists_depth_to (S depth) E ψ2 =
    S (maximal_exists_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
e: E ∈ free_evars ψ1
e0: E ∈ free_evars ψ2
S (maximal_exists_depth_to depth E ψ1)
`max` S (maximal_exists_depth_to depth E ψ2) =
S
  (maximal_exists_depth_to depth E ψ1
   `max` maximal_exists_depth_to depth E ψ2) simpl.
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ1
  → maximal_exists_depth_to (S depth) E ψ1 =
    S (maximal_exists_depth_to depth E ψ1)
IHψ2: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ2
  → maximal_exists_depth_to (S depth) E ψ2 =
    S (maximal_exists_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
e: E ∈ free_evars ψ1
e0: E ∈ free_evars ψ2
S
  (maximal_exists_depth_to depth E ψ1
   `max` maximal_exists_depth_to depth E ψ2) =
S
  (maximal_exists_depth_to depth E ψ1
   `max` maximal_exists_depth_to depth E ψ2) reflexivity.
      }
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ1
  → maximal_exists_depth_to (S depth) E ψ1 =
    S (maximal_exists_depth_to depth E ψ1)
IHψ2: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ2
  → maximal_exists_depth_to (S depth) E ψ2 =
    S (maximal_exists_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
e: E ∈ free_evars ψ1
n: E ∉ free_evars ψ2
maximal_exists_depth_to (S depth) E ψ1
`max` maximal_exists_depth_to (S depth) E ψ2 =
S
  (maximal_exists_depth_to depth E ψ1
   `max` maximal_exists_depth_to depth E ψ2)
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ1
  → maximal_exists_depth_to (S depth) E ψ1 =
    S (maximal_exists_depth_to depth E ψ1)
IHψ2: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ2
  → maximal_exists_depth_to (S depth) E ψ2 =
    S (maximal_exists_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
n: E ∉ free_evars ψ1
e: E ∈ free_evars ψ2
maximal_exists_depth_to (S depth) E ψ1
`max` maximal_exists_depth_to (S depth) E ψ2 =
S
  (maximal_exists_depth_to depth E ψ1
   `max` maximal_exists_depth_to depth E ψ2)
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ1
  → maximal_exists_depth_to (S depth) E ψ1 =
    S (maximal_exists_depth_to depth E ψ1)
IHψ2: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ2
  → maximal_exists_depth_to (S depth) E ψ2 =
    S (maximal_exists_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
n: E ∉ free_evars ψ1
n0: E ∉ free_evars ψ2
maximal_exists_depth_to (S depth) E ψ1
`max` maximal_exists_depth_to (S depth) E ψ2 =
S
  (maximal_exists_depth_to depth E ψ1
   `max` maximal_exists_depth_to depth E ψ2)
      {
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ1
  → maximal_exists_depth_to (S depth) E ψ1 =
    S (maximal_exists_depth_to depth E ψ1)
IHψ2: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ2
  → maximal_exists_depth_to (S depth) E ψ2 =
    S (maximal_exists_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
e: E ∈ free_evars ψ1
n: E ∉ free_evars ψ2
maximal_exists_depth_to (S depth) E ψ1
`max` maximal_exists_depth_to (S depth) E ψ2 =
S
  (maximal_exists_depth_to depth E ψ1
   `max` maximal_exists_depth_to depth E ψ2)
        rewrite IHψ1.
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ1
  → maximal_exists_depth_to (S depth) E ψ1 =
    S (maximal_exists_depth_to depth E ψ1)
IHψ2: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ2
  → maximal_exists_depth_to (S depth) E ψ2 =
    S (maximal_exists_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
e: E ∈ free_evars ψ1
n: E ∉ free_evars ψ2
E ∈ free_evars ψ1
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ1
  → maximal_exists_depth_to (S depth) E ψ1 =
    S (maximal_exists_depth_to depth E ψ1)
IHψ2: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ2
  → maximal_exists_depth_to (S depth) E ψ2 =
    S (maximal_exists_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
e: E ∈ free_evars ψ1
n: E ∉ free_evars ψ2
S (maximal_exists_depth_to depth E ψ1)
`max` maximal_exists_depth_to (S depth) E ψ2 =
S
  (maximal_exists_depth_to depth E ψ1
   `max` maximal_exists_depth_to depth E ψ2) assumption.
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ1
  → maximal_exists_depth_to (S depth) E ψ1 =
    S (maximal_exists_depth_to depth E ψ1)
IHψ2: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ2
  → maximal_exists_depth_to (S depth) E ψ2 =
    S (maximal_exists_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
e: E ∈ free_evars ψ1
n: E ∉ free_evars ψ2
S (maximal_exists_depth_to depth E ψ1)
`max` maximal_exists_depth_to (S depth) E ψ2 =
S
  (maximal_exists_depth_to depth E ψ1
   `max` maximal_exists_depth_to depth E ψ2)
        apply maximal_exists_depth_to_0 with (depth := S depth) in n
          as n'.
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ1
  → maximal_exists_depth_to (S depth) E ψ1 =
    S (maximal_exists_depth_to depth E ψ1)
IHψ2: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ2
  → maximal_exists_depth_to (S depth) E ψ2 =
    S (maximal_exists_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
e: E ∈ free_evars ψ1
n: E ∉ free_evars ψ2
n': maximal_exists_depth_to (S depth) E ψ2 = 0
S (maximal_exists_depth_to depth E ψ1)
`max` maximal_exists_depth_to (S depth) E ψ2 =
S
  (maximal_exists_depth_to depth E ψ1
   `max` maximal_exists_depth_to depth E ψ2)
        apply maximal_exists_depth_to_0 with (depth := depth) in n.
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ1
  → maximal_exists_depth_to (S depth) E ψ1 =
    S (maximal_exists_depth_to depth E ψ1)
IHψ2: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ2
  → maximal_exists_depth_to (S depth) E ψ2 =
    S (maximal_exists_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
e: E ∈ free_evars ψ1
n: maximal_exists_depth_to depth E ψ2 = 0
n': maximal_exists_depth_to (S depth) E ψ2 = 0
S (maximal_exists_depth_to depth E ψ1)
`max` maximal_exists_depth_to (S depth) E ψ2 =
S
  (maximal_exists_depth_to depth E ψ1
   `max` maximal_exists_depth_to depth E ψ2)
        rewrite n.
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ1
  → maximal_exists_depth_to (S depth) E ψ1 =
    S (maximal_exists_depth_to depth E ψ1)
IHψ2: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ2
  → maximal_exists_depth_to (S depth) E ψ2 =
    S (maximal_exists_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
e: E ∈ free_evars ψ1
n: maximal_exists_depth_to depth E ψ2 = 0
n': maximal_exists_depth_to (S depth) E ψ2 = 0
S (maximal_exists_depth_to depth E ψ1)
`max` maximal_exists_depth_to (S depth) E ψ2 =
S (maximal_exists_depth_to depth E ψ1 `max` 0) lia. 
      }
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ1
  → maximal_exists_depth_to (S depth) E ψ1 =
    S (maximal_exists_depth_to depth E ψ1)
IHψ2: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ2
  → maximal_exists_depth_to (S depth) E ψ2 =
    S (maximal_exists_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
n: E ∉ free_evars ψ1
e: E ∈ free_evars ψ2
maximal_exists_depth_to (S depth) E ψ1
`max` maximal_exists_depth_to (S depth) E ψ2 =
S
  (maximal_exists_depth_to depth E ψ1
   `max` maximal_exists_depth_to depth E ψ2)
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ1
  → maximal_exists_depth_to (S depth) E ψ1 =
    S (maximal_exists_depth_to depth E ψ1)
IHψ2: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ2
  → maximal_exists_depth_to (S depth) E ψ2 =
    S (maximal_exists_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
n: E ∉ free_evars ψ1
n0: E ∉ free_evars ψ2
maximal_exists_depth_to (S depth) E ψ1
`max` maximal_exists_depth_to (S depth) E ψ2 =
S
  (maximal_exists_depth_to depth E ψ1
   `max` maximal_exists_depth_to depth E ψ2)
      {
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ1
  → maximal_exists_depth_to (S depth) E ψ1 =
    S (maximal_exists_depth_to depth E ψ1)
IHψ2: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ2
  → maximal_exists_depth_to (S depth) E ψ2 =
    S (maximal_exists_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
n: E ∉ free_evars ψ1
e: E ∈ free_evars ψ2
maximal_exists_depth_to (S depth) E ψ1
`max` maximal_exists_depth_to (S depth) E ψ2 =
S
  (maximal_exists_depth_to depth E ψ1
   `max` maximal_exists_depth_to depth E ψ2)
        rewrite IHψ2.
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ1
  → maximal_exists_depth_to (S depth) E ψ1 =
    S (maximal_exists_depth_to depth E ψ1)
IHψ2: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ2
  → maximal_exists_depth_to (S depth) E ψ2 =
    S (maximal_exists_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
n: E ∉ free_evars ψ1
e: E ∈ free_evars ψ2
E ∈ free_evars ψ2
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ1
  → maximal_exists_depth_to (S depth) E ψ1 =
    S (maximal_exists_depth_to depth E ψ1)
IHψ2: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ2
  → maximal_exists_depth_to (S depth) E ψ2 =
    S (maximal_exists_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
n: E ∉ free_evars ψ1
e: E ∈ free_evars ψ2
maximal_exists_depth_to (S depth) E ψ1
`max` S (maximal_exists_depth_to depth E ψ2) =
S
  (maximal_exists_depth_to depth E ψ1
   `max` maximal_exists_depth_to depth E ψ2) assumption.
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ1
  → maximal_exists_depth_to (S depth) E ψ1 =
    S (maximal_exists_depth_to depth E ψ1)
IHψ2: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ2
  → maximal_exists_depth_to (S depth) E ψ2 =
    S (maximal_exists_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
n: E ∉ free_evars ψ1
e: E ∈ free_evars ψ2
maximal_exists_depth_to (S depth) E ψ1
`max` S (maximal_exists_depth_to depth E ψ2) =
S
  (maximal_exists_depth_to depth E ψ1
   `max` maximal_exists_depth_to depth E ψ2)
        apply maximal_exists_depth_to_0 with (depth := S depth) in n
          as n'.
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ1
  → maximal_exists_depth_to (S depth) E ψ1 =
    S (maximal_exists_depth_to depth E ψ1)
IHψ2: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ2
  → maximal_exists_depth_to (S depth) E ψ2 =
    S (maximal_exists_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
n: E ∉ free_evars ψ1
e: E ∈ free_evars ψ2
n': maximal_exists_depth_to (S depth) E ψ1 = 0
maximal_exists_depth_to (S depth) E ψ1
`max` S (maximal_exists_depth_to depth E ψ2) =
S
  (maximal_exists_depth_to depth E ψ1
   `max` maximal_exists_depth_to depth E ψ2)
        apply maximal_exists_depth_to_0 with (depth := depth) in n.
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ1
  → maximal_exists_depth_to (S depth) E ψ1 =
    S (maximal_exists_depth_to depth E ψ1)
IHψ2: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ2
  → maximal_exists_depth_to (S depth) E ψ2 =
    S (maximal_exists_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
n: maximal_exists_depth_to depth E ψ1 = 0
e: E ∈ free_evars ψ2
n': maximal_exists_depth_to (S depth) E ψ1 = 0
maximal_exists_depth_to (S depth) E ψ1
`max` S (maximal_exists_depth_to depth E ψ2) =
S
  (maximal_exists_depth_to depth E ψ1
   `max` maximal_exists_depth_to depth E ψ2)
        rewrite n.
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ1
  → maximal_exists_depth_to (S depth) E ψ1 =
    S (maximal_exists_depth_to depth E ψ1)
IHψ2: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ2
  → maximal_exists_depth_to (S depth) E ψ2 =
    S (maximal_exists_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
n: maximal_exists_depth_to depth E ψ1 = 0
e: E ∈ free_evars ψ2
n': maximal_exists_depth_to (S depth) E ψ1 = 0
maximal_exists_depth_to (S depth) E ψ1
`max` S (maximal_exists_depth_to depth E ψ2) =
S (0 `max` maximal_exists_depth_to depth E ψ2) lia. 
      }
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ1
  → maximal_exists_depth_to (S depth) E ψ1 =
    S (maximal_exists_depth_to depth E ψ1)
IHψ2: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ2
  → maximal_exists_depth_to (S depth) E ψ2 =
    S (maximal_exists_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
n: E ∉ free_evars ψ1
n0: E ∉ free_evars ψ2
maximal_exists_depth_to (S depth) E ψ1
`max` maximal_exists_depth_to (S depth) E ψ2 =
S
  (maximal_exists_depth_to depth E ψ1
   `max` maximal_exists_depth_to depth E ψ2)
      {
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ1
  → maximal_exists_depth_to (S depth) E ψ1 =
    S (maximal_exists_depth_to depth E ψ1)
IHψ2: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ2
  → maximal_exists_depth_to (S depth) E ψ2 =
    S (maximal_exists_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
n: E ∉ free_evars ψ1
n0: E ∉ free_evars ψ2
maximal_exists_depth_to (S depth) E ψ1
`max` maximal_exists_depth_to (S depth) E ψ2 =
S
  (maximal_exists_depth_to depth E ψ1
   `max` maximal_exists_depth_to depth E ψ2)
        exfalso.
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ1
  → maximal_exists_depth_to (S depth) E ψ1 =
    S (maximal_exists_depth_to depth E ψ1)
IHψ2: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ2
  → maximal_exists_depth_to (S depth) E ψ2 =
    S (maximal_exists_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
n: E ∉ free_evars ψ1
n0: E ∉ free_evars ψ2
False set_solver.
      }
    }
  Qed.

  Lemma evar_open_exists_depth φ depth x e : forall dbi,
    x <> e ->
    maximal_exists_depth_to depth x φ^{evar: dbi ↦ e} = maximal_exists_depth_to depth x φ.
Σ: Signature
φ: Pattern
depth: nat
x, e: evar
∀ dbi : db_index,
  x ≠ e
  → maximal_exists_depth_to depth x φ^{evar:dbi↦e} =
    maximal_exists_depth_to depth x φ
  Proof.
Σ: Signature
φ: Pattern
depth: nat
x, e: evar
∀ dbi : db_index,
  x ≠ e
  → maximal_exists_depth_to depth x φ^{evar:dbi↦e} =
    maximal_exists_depth_to depth x φ
    move: depth.
Σ: Signature
φ: Pattern
x, e: evar
∀ (depth : nat) (dbi : db_index),
  x ≠ e
  → maximal_exists_depth_to depth x φ^{evar:dbi↦e} =
    maximal_exists_depth_to depth x φ
    induction φ; intros depth HeNq; cbn; trivial; intro.
Σ: Signature
n: db_index
x, e: evar
depth: nat
HeNq: db_index
H: x ≠ e
maximal_exists_depth_to depth x
  match compare_nat n HeNq with
  | Nat_less _ _ _ => patt_bound_evar n
  | Nat_equal _ _ _ => patt_free_evar e
  | Nat_greater _ _ _ => patt_bound_evar (Nat.pred n)
  end = 0
Σ: Signature
φ1, φ2: Pattern
x, e: evar
IHφ1: ∀ (depth : nat) (dbi : db_index),
  x ≠ e
  → maximal_exists_depth_to depth x
      φ1^{evar:dbi↦e} =
    maximal_exists_depth_to depth x φ1
IHφ2: ∀ (depth : nat) (dbi : db_index),
  x ≠ e
  → maximal_exists_depth_to depth x
      φ2^{evar:dbi↦e} =
    maximal_exists_depth_to depth x φ2
depth: nat
HeNq: db_index
H: x ≠ e
maximal_exists_depth_to depth x
  φ1^[evar:HeNq↦patt_free_evar e]
`max` maximal_exists_depth_to depth x
        φ2^[evar:HeNq↦patt_free_evar e] =
maximal_exists_depth_to depth x φ1
`max` maximal_exists_depth_to depth x φ2
Σ: Signature
φ1, φ2: Pattern
x, e: evar
IHφ1: ∀ (depth : nat) (dbi : db_index),
  x ≠ e
  → maximal_exists_depth_to depth x
      φ1^{evar:dbi↦e} =
    maximal_exists_depth_to depth x φ1
IHφ2: ∀ (depth : nat) (dbi : db_index),
  x ≠ e
  → maximal_exists_depth_to depth x
      φ2^{evar:dbi↦e} =
    maximal_exists_depth_to depth x φ2
depth: nat
HeNq: db_index
H: x ≠ e
maximal_exists_depth_to depth x
  φ1^[evar:HeNq↦patt_free_evar e]
`max` maximal_exists_depth_to depth x
        φ2^[evar:HeNq↦patt_free_evar e] =
maximal_exists_depth_to depth x φ1
`max` maximal_exists_depth_to depth x φ2
Σ: Signature
φ: Pattern
x, e: evar
IHφ: ∀ (depth : nat) (dbi : db_index),
  x ≠ e
  → maximal_exists_depth_to depth x
      φ^{evar:dbi↦e} =
    maximal_exists_depth_to depth x φ
depth: nat
HeNq: db_index
H: x ≠ e
maximal_exists_depth_to 
  (S depth) x φ^[evar:S HeNq↦
  patt_free_evar e] =
maximal_exists_depth_to (S depth) x φ
Σ: Signature
φ: Pattern
x, e: evar
IHφ: ∀ (depth : nat) (dbi : db_index),
  x ≠ e
  → maximal_exists_depth_to depth x
      φ^{evar:dbi↦e} =
    maximal_exists_depth_to depth x φ
depth: nat
HeNq: db_index
H: x ≠ e
maximal_exists_depth_to depth x
  φ^[evar:HeNq↦patt_free_evar e] =
maximal_exists_depth_to depth x φ
    case_match; auto.
Σ: Signature
n: db_index
x, e: evar
depth: nat
HeNq: db_index
H: x ≠ e
e0: n = HeNq
H0: compare_nat n HeNq = Nat_equal n HeNq e0
maximal_exists_depth_to depth x (patt_free_evar e) = 0
Σ: Signature
φ1, φ2: Pattern
x, e: evar
IHφ1: ∀ (depth : nat) (dbi : db_index),
  x ≠ e
  → maximal_exists_depth_to depth x
      φ1^{evar:dbi↦e} =
    maximal_exists_depth_to depth x φ1
IHφ2: ∀ (depth : nat) (dbi : db_index),
  x ≠ e
  → maximal_exists_depth_to depth x
      φ2^{evar:dbi↦e} =
    maximal_exists_depth_to depth x φ2
depth: nat
HeNq: db_index
H: x ≠ e
maximal_exists_depth_to depth x
  φ1^[evar:HeNq↦patt_free_evar e]
`max` maximal_exists_depth_to depth x
        φ2^[evar:HeNq↦patt_free_evar e] =
maximal_exists_depth_to depth x φ1
`max` maximal_exists_depth_to depth x φ2
Σ: Signature
φ1, φ2: Pattern
x, e: evar
IHφ1: ∀ (depth : nat) (dbi : db_index),
  x ≠ e
  → maximal_exists_depth_to depth x
      φ1^{evar:dbi↦e} =
    maximal_exists_depth_to depth x φ1
IHφ2: ∀ (depth : nat) (dbi : db_index),
  x ≠ e
  → maximal_exists_depth_to depth x
      φ2^{evar:dbi↦e} =
    maximal_exists_depth_to depth x φ2
depth: nat
HeNq: db_index
H: x ≠ e
maximal_exists_depth_to depth x
  φ1^[evar:HeNq↦patt_free_evar e]
`max` maximal_exists_depth_to depth x
        φ2^[evar:HeNq↦patt_free_evar e] =
maximal_exists_depth_to depth x φ1
`max` maximal_exists_depth_to depth x φ2
Σ: Signature
φ: Pattern
x, e: evar
IHφ: ∀ (depth : nat) (dbi : db_index),
  x ≠ e
  → maximal_exists_depth_to depth x
      φ^{evar:dbi↦e} =
    maximal_exists_depth_to depth x φ
depth: nat
HeNq: db_index
H: x ≠ e
maximal_exists_depth_to 
  (S depth) x φ^[evar:S HeNq↦
  patt_free_evar e] =
maximal_exists_depth_to (S depth) x φ
Σ: Signature
φ: Pattern
x, e: evar
IHφ: ∀ (depth : nat) (dbi : db_index),
  x ≠ e
  → maximal_exists_depth_to depth x
      φ^{evar:dbi↦e} =
    maximal_exists_depth_to depth x φ
depth: nat
HeNq: db_index
H: x ≠ e
maximal_exists_depth_to depth x
  φ^[evar:HeNq↦patt_free_evar e] =
maximal_exists_depth_to depth x φ cbn.
Σ: Signature
n: db_index
x, e: evar
depth: nat
HeNq: db_index
H: x ≠ e
e0: n = HeNq
H0: compare_nat n HeNq = Nat_equal n HeNq e0
(if decide (e = x) then depth else 0) = 0
Σ: Signature
φ1, φ2: Pattern
x, e: evar
IHφ1: ∀ (depth : nat) (dbi : db_index),
  x ≠ e
  → maximal_exists_depth_to depth x
      φ1^{evar:dbi↦e} =
    maximal_exists_depth_to depth x φ1
IHφ2: ∀ (depth : nat) (dbi : db_index),
  x ≠ e
  → maximal_exists_depth_to depth x
      φ2^{evar:dbi↦e} =
    maximal_exists_depth_to depth x φ2
depth: nat
HeNq: db_index
H: x ≠ e
maximal_exists_depth_to depth x
  φ1^[evar:HeNq↦patt_free_evar e]
`max` maximal_exists_depth_to depth x
        φ2^[evar:HeNq↦patt_free_evar e] =
maximal_exists_depth_to depth x φ1
`max` maximal_exists_depth_to depth x φ2
Σ: Signature
φ1, φ2: Pattern
x, e: evar
IHφ1: ∀ (depth : nat) (dbi : db_index),
  x ≠ e
  → maximal_exists_depth_to depth x
      φ1^{evar:dbi↦e} =
    maximal_exists_depth_to depth x φ1
IHφ2: ∀ (depth : nat) (dbi : db_index),
  x ≠ e
  → maximal_exists_depth_to depth x
      φ2^{evar:dbi↦e} =
    maximal_exists_depth_to depth x φ2
depth: nat
HeNq: db_index
H: x ≠ e
maximal_exists_depth_to depth x
  φ1^[evar:HeNq↦patt_free_evar e]
`max` maximal_exists_depth_to depth x
        φ2^[evar:HeNq↦patt_free_evar e] =
maximal_exists_depth_to depth x φ1
`max` maximal_exists_depth_to depth x φ2
Σ: Signature
φ: Pattern
x, e: evar
IHφ: ∀ (depth : nat) (dbi : db_index),
  x ≠ e
  → maximal_exists_depth_to depth x
      φ^{evar:dbi↦e} =
    maximal_exists_depth_to depth x φ
depth: nat
HeNq: db_index
H: x ≠ e
maximal_exists_depth_to 
  (S depth) x φ^[evar:S HeNq↦
  patt_free_evar e] =
maximal_exists_depth_to (S depth) x φ
Σ: Signature
φ: Pattern
x, e: evar
IHφ: ∀ (depth : nat) (dbi : db_index),
  x ≠ e
  → maximal_exists_depth_to depth x
      φ^{evar:dbi↦e} =
    maximal_exists_depth_to depth x φ
depth: nat
HeNq: db_index
H: x ≠ e
maximal_exists_depth_to depth x
  φ^[evar:HeNq↦patt_free_evar e] =
maximal_exists_depth_to depth x φ case_match.
Σ: Signature
n: db_index
x, e: evar
depth: nat
HeNq: db_index
H: x ≠ e
e0: n = HeNq
H0: compare_nat n HeNq = Nat_equal n HeNq e0
e1: e = x
H1: decide (e = x) = left e1
depth = 0
Σ: Signature
n: db_index
x, e: evar
depth: nat
HeNq: db_index
H: x ≠ e
e0: n = HeNq
H0: compare_nat n HeNq = Nat_equal n HeNq e0
n0: e ≠ x
H1: decide (e = x) = right n0
0 = 0
Σ: Signature
φ1, φ2: Pattern
x, e: evar
IHφ1: ∀ (depth : nat) (dbi : db_index),
  x ≠ e
  → maximal_exists_depth_to depth x
      φ1^{evar:dbi↦e} =
    maximal_exists_depth_to depth x φ1
IHφ2: ∀ (depth : nat) (dbi : db_index),
  x ≠ e
  → maximal_exists_depth_to depth x
      φ2^{evar:dbi↦e} =
    maximal_exists_depth_to depth x φ2
depth: nat
HeNq: db_index
H: x ≠ e
maximal_exists_depth_to depth x
  φ1^[evar:HeNq↦patt_free_evar e]
`max` maximal_exists_depth_to depth x
        φ2^[evar:HeNq↦patt_free_evar e] =
maximal_exists_depth_to depth x φ1
`max` maximal_exists_depth_to depth x φ2
Σ: Signature
φ1, φ2: Pattern
x, e: evar
IHφ1: ∀ (depth : nat) (dbi : db_index),
  x ≠ e
  → maximal_exists_depth_to depth x
      φ1^{evar:dbi↦e} =
    maximal_exists_depth_to depth x φ1
IHφ2: ∀ (depth : nat) (dbi : db_index),
  x ≠ e
  → maximal_exists_depth_to depth x
      φ2^{evar:dbi↦e} =
    maximal_exists_depth_to depth x φ2
depth: nat
HeNq: db_index
H: x ≠ e
maximal_exists_depth_to depth x
  φ1^[evar:HeNq↦patt_free_evar e]
`max` maximal_exists_depth_to depth x
        φ2^[evar:HeNq↦patt_free_evar e] =
maximal_exists_depth_to depth x φ1
`max` maximal_exists_depth_to depth x φ2
Σ: Signature
φ: Pattern
x, e: evar
IHφ: ∀ (depth : nat) (dbi : db_index),
  x ≠ e
  → maximal_exists_depth_to depth x
      φ^{evar:dbi↦e} =
    maximal_exists_depth_to depth x φ
depth: nat
HeNq: db_index
H: x ≠ e
maximal_exists_depth_to 
  (S depth) x φ^[evar:S HeNq↦
  patt_free_evar e] =
maximal_exists_depth_to (S depth) x φ
Σ: Signature
φ: Pattern
x, e: evar
IHφ: ∀ (depth : nat) (dbi : db_index),
  x ≠ e
  → maximal_exists_depth_to depth x
      φ^{evar:dbi↦e} =
    maximal_exists_depth_to depth x φ
depth: nat
HeNq: db_index
H: x ≠ e
maximal_exists_depth_to depth x
  φ^[evar:HeNq↦patt_free_evar e] =
maximal_exists_depth_to depth x φ congruence.
Σ: Signature
n: db_index
x, e: evar
depth: nat
HeNq: db_index
H: x ≠ e
e0: n = HeNq
H0: compare_nat n HeNq = Nat_equal n HeNq e0
n0: e ≠ x
H1: decide (e = x) = right n0
0 = 0
Σ: Signature
φ1, φ2: Pattern
x, e: evar
IHφ1: ∀ (depth : nat) (dbi : db_index),
  x ≠ e
  → maximal_exists_depth_to depth x
      φ1^{evar:dbi↦e} =
    maximal_exists_depth_to depth x φ1
IHφ2: ∀ (depth : nat) (dbi : db_index),
  x ≠ e
  → maximal_exists_depth_to depth x
      φ2^{evar:dbi↦e} =
    maximal_exists_depth_to depth x φ2
depth: nat
HeNq: db_index
H: x ≠ e
maximal_exists_depth_to depth x
  φ1^[evar:HeNq↦patt_free_evar e]
`max` maximal_exists_depth_to depth x
        φ2^[evar:HeNq↦patt_free_evar e] =
maximal_exists_depth_to depth x φ1
`max` maximal_exists_depth_to depth x φ2
Σ: Signature
φ1, φ2: Pattern
x, e: evar
IHφ1: ∀ (depth : nat) (dbi : db_index),
  x ≠ e
  → maximal_exists_depth_to depth x
      φ1^{evar:dbi↦e} =
    maximal_exists_depth_to depth x φ1
IHφ2: ∀ (depth : nat) (dbi : db_index),
  x ≠ e
  → maximal_exists_depth_to depth x
      φ2^{evar:dbi↦e} =
    maximal_exists_depth_to depth x φ2
depth: nat
HeNq: db_index
H: x ≠ e
maximal_exists_depth_to depth x
  φ1^[evar:HeNq↦patt_free_evar e]
`max` maximal_exists_depth_to depth x
        φ2^[evar:HeNq↦patt_free_evar e] =
maximal_exists_depth_to depth x φ1
`max` maximal_exists_depth_to depth x φ2
Σ: Signature
φ: Pattern
x, e: evar
IHφ: ∀ (depth : nat) (dbi : db_index),
  x ≠ e
  → maximal_exists_depth_to depth x
      φ^{evar:dbi↦e} =
    maximal_exists_depth_to depth x φ
depth: nat
HeNq: db_index
H: x ≠ e
maximal_exists_depth_to 
  (S depth) x φ^[evar:S HeNq↦
  patt_free_evar e] =
maximal_exists_depth_to (S depth) x φ
Σ: Signature
φ: Pattern
x, e: evar
IHφ: ∀ (depth : nat) (dbi : db_index),
  x ≠ e
  → maximal_exists_depth_to depth x
      φ^{evar:dbi↦e} =
    maximal_exists_depth_to depth x φ
depth: nat
HeNq: db_index
H: x ≠ e
maximal_exists_depth_to depth x
  φ^[evar:HeNq↦patt_free_evar e] =
maximal_exists_depth_to depth x φ lia.
Σ: Signature
φ1, φ2: Pattern
x, e: evar
IHφ1: ∀ (depth : nat) (dbi : db_index),
  x ≠ e
  → maximal_exists_depth_to depth x
      φ1^{evar:dbi↦e} =
    maximal_exists_depth_to depth x φ1
IHφ2: ∀ (depth : nat) (dbi : db_index),
  x ≠ e
  → maximal_exists_depth_to depth x
      φ2^{evar:dbi↦e} =
    maximal_exists_depth_to depth x φ2
depth: nat
HeNq: db_index
H: x ≠ e
maximal_exists_depth_to depth x
  φ1^[evar:HeNq↦patt_free_evar e]
`max` maximal_exists_depth_to depth x
        φ2^[evar:HeNq↦patt_free_evar e] =
maximal_exists_depth_to depth x φ1
`max` maximal_exists_depth_to depth x φ2
Σ: Signature
φ1, φ2: Pattern
x, e: evar
IHφ1: ∀ (depth : nat) (dbi : db_index),
  x ≠ e
  → maximal_exists_depth_to depth x
      φ1^{evar:dbi↦e} =
    maximal_exists_depth_to depth x φ1
IHφ2: ∀ (depth : nat) (dbi : db_index),
  x ≠ e
  → maximal_exists_depth_to depth x
      φ2^{evar:dbi↦e} =
    maximal_exists_depth_to depth x φ2
depth: nat
HeNq: db_index
H: x ≠ e
maximal_exists_depth_to depth x
  φ1^[evar:HeNq↦patt_free_evar e]
`max` maximal_exists_depth_to depth x
        φ2^[evar:HeNq↦patt_free_evar e] =
maximal_exists_depth_to depth x φ1
`max` maximal_exists_depth_to depth x φ2
Σ: Signature
φ: Pattern
x, e: evar
IHφ: ∀ (depth : nat) (dbi : db_index),
  x ≠ e
  → maximal_exists_depth_to depth x
      φ^{evar:dbi↦e} =
    maximal_exists_depth_to depth x φ
depth: nat
HeNq: db_index
H: x ≠ e
maximal_exists_depth_to (S depth) x
  φ^[evar:S HeNq↦patt_free_evar e] =
maximal_exists_depth_to (S depth) x φ
Σ: Signature
φ: Pattern
x, e: evar
IHφ: ∀ (depth : nat) (dbi : db_index),
  x ≠ e
  → maximal_exists_depth_to depth x
      φ^{evar:dbi↦e} =
    maximal_exists_depth_to depth x φ
depth: nat
HeNq: db_index
H: x ≠ e
maximal_exists_depth_to depth x
  φ^[evar:HeNq↦patt_free_evar e] =
maximal_exists_depth_to depth x φ
    1-2: rewrite IHφ1; auto; rewrite IHφ2; auto.
Σ: Signature
φ: Pattern
x, e: evar
IHφ: ∀ (depth : nat) (dbi : db_index),
x ≠ e
→ maximal_exists_depth_to depth x φ^{evar:dbi↦e} =
maximal_exists_depth_to depth x φ
depth: nat
HeNq: db_index
H: x ≠ e
maximal_exists_depth_to (S depth) x
  φ^[evar:S HeNq↦patt_free_evar e] =
maximal_exists_depth_to (S depth) x φ
Σ: Signature
φ: Pattern
x, e: evar
IHφ: ∀ (depth : nat) (dbi : db_index),
  x ≠ e
  → maximal_exists_depth_to depth x
      φ^{evar:dbi↦e} =
    maximal_exists_depth_to depth x φ
depth: nat
HeNq: db_index
H: x ≠ e
maximal_exists_depth_to depth x
  φ^[evar:HeNq↦patt_free_evar e] =
maximal_exists_depth_to depth x φ
    rewrite IHφ; auto.
Σ: Signature
φ: Pattern
x, e: evar
IHφ: ∀ (depth : nat) (dbi : db_index),
x ≠ e
→ maximal_exists_depth_to depth x φ^{evar:dbi↦e} =
maximal_exists_depth_to depth x φ
depth: nat
HeNq: db_index
H: x ≠ e
maximal_exists_depth_to depth x
  φ^[evar:HeNq↦patt_free_evar e] =
maximal_exists_depth_to depth x φ
    rewrite IHφ; auto.
  Qed.

  Lemma svar_open_exists_depth φ depth x X : forall dbi,
    maximal_exists_depth_to depth x φ^{svar: dbi ↦ X} = maximal_exists_depth_to depth x φ.
Σ: Signature
φ: Pattern
depth: nat
x: evar
X: svar
∀ dbi : db_index,
  maximal_exists_depth_to depth x φ^{svar:dbi↦X} =
  maximal_exists_depth_to depth x φ
  Proof.
Σ: Signature
φ: Pattern
depth: nat
x: evar
X: svar
∀ dbi : db_index,
  maximal_exists_depth_to depth x φ^{svar:dbi↦X} =
  maximal_exists_depth_to depth x φ
    move: depth.
Σ: Signature
φ: Pattern
x: evar
X: svar
∀ (depth : nat) (dbi : db_index),
  maximal_exists_depth_to depth x φ^{svar:dbi↦X} =
  maximal_exists_depth_to depth x φ
    induction φ; intro depth; cbn; trivial; intro.
Σ: Signature
n: db_index
x: evar
X: svar
depth: nat
dbi: db_index
maximal_exists_depth_to depth x
  match compare_nat n dbi with
  | Nat_less _ _ _ => patt_bound_svar n
  | Nat_equal _ _ _ => patt_free_svar X
  | Nat_greater _ _ _ => patt_bound_svar (Nat.pred n)
  end = 0
Σ: Signature
φ1, φ2: Pattern
x: evar
X: svar
IHφ1: ∀ (depth : nat) (dbi : db_index),
  maximal_exists_depth_to depth x
    φ1^{svar:dbi↦X} =
  maximal_exists_depth_to depth x φ1
IHφ2: ∀ (depth : nat) (dbi : db_index),
  maximal_exists_depth_to depth x
    φ2^{svar:dbi↦X} =
  maximal_exists_depth_to depth x φ2
depth: nat
dbi: db_index
maximal_exists_depth_to depth x
  φ1^[svar:dbi↦patt_free_svar X]
`max` maximal_exists_depth_to depth x
        φ2^[svar:dbi↦patt_free_svar X] =
maximal_exists_depth_to depth x φ1
`max` maximal_exists_depth_to depth x φ2
Σ: Signature
φ1, φ2: Pattern
x: evar
X: svar
IHφ1: ∀ (depth : nat) (dbi : db_index),
  maximal_exists_depth_to depth x
    φ1^{svar:dbi↦X} =
  maximal_exists_depth_to depth x φ1
IHφ2: ∀ (depth : nat) (dbi : db_index),
  maximal_exists_depth_to depth x
    φ2^{svar:dbi↦X} =
  maximal_exists_depth_to depth x φ2
depth: nat
dbi: db_index
maximal_exists_depth_to depth x
  φ1^[svar:dbi↦patt_free_svar X]
`max` maximal_exists_depth_to depth x
        φ2^[svar:dbi↦patt_free_svar X] =
maximal_exists_depth_to depth x φ1
`max` maximal_exists_depth_to depth x φ2
Σ: Signature
φ: Pattern
x: evar
X: svar
IHφ: ∀ (depth : nat) (dbi : db_index),
  maximal_exists_depth_to depth x φ^{svar:dbi↦X} =
  maximal_exists_depth_to depth x φ
depth: nat
dbi: db_index
maximal_exists_depth_to 
  (S depth) x φ^[svar:dbi↦
  patt_free_svar X] =
maximal_exists_depth_to (S depth) x φ
Σ: Signature
φ: Pattern
x: evar
X: svar
IHφ: ∀ (depth : nat) (dbi : db_index),
  maximal_exists_depth_to depth x φ^{svar:dbi↦X} =
  maximal_exists_depth_to depth x φ
depth: nat
dbi: db_index
maximal_exists_depth_to depth x
  φ^[svar:S dbi↦patt_free_svar X] =
maximal_exists_depth_to depth x φ
    case_match; auto.
Σ: Signature
φ1, φ2: Pattern
x: evar
X: svar
IHφ1: ∀ (depth : nat) (dbi : db_index),
  maximal_exists_depth_to depth x
    φ1^{svar:dbi↦X} =
  maximal_exists_depth_to depth x φ1
IHφ2: ∀ (depth : nat) (dbi : db_index),
  maximal_exists_depth_to depth x
    φ2^{svar:dbi↦X} =
  maximal_exists_depth_to depth x φ2
depth: nat
dbi: db_index
maximal_exists_depth_to depth x
  φ1^[svar:dbi↦patt_free_svar X]
`max` maximal_exists_depth_to depth x
        φ2^[svar:dbi↦patt_free_svar X] =
maximal_exists_depth_to depth x φ1
`max` maximal_exists_depth_to depth x φ2
Σ: Signature
φ1, φ2: Pattern
x: evar
X: svar
IHφ1: ∀ (depth : nat) (dbi : db_index),
  maximal_exists_depth_to depth x
    φ1^{svar:dbi↦X} =
  maximal_exists_depth_to depth x φ1
IHφ2: ∀ (depth : nat) (dbi : db_index),
  maximal_exists_depth_to depth x
    φ2^{svar:dbi↦X} =
  maximal_exists_depth_to depth x φ2
depth: nat
dbi: db_index
maximal_exists_depth_to depth x
  φ1^[svar:dbi↦patt_free_svar X]
`max` maximal_exists_depth_to depth x
        φ2^[svar:dbi↦patt_free_svar X] =
maximal_exists_depth_to depth x φ1
`max` maximal_exists_depth_to depth x φ2
Σ: Signature
φ: Pattern
x: evar
X: svar
IHφ: ∀ (depth : nat) (dbi : db_index),
  maximal_exists_depth_to depth x φ^{svar:dbi↦X} =
  maximal_exists_depth_to depth x φ
depth: nat
dbi: db_index
maximal_exists_depth_to (S depth) x
  φ^[svar:dbi↦patt_free_svar X] =
maximal_exists_depth_to (S depth) x φ
Σ: Signature
φ: Pattern
x: evar
X: svar
IHφ: ∀ (depth : nat) (dbi : db_index),
  maximal_exists_depth_to depth x φ^{svar:dbi↦X} =
  maximal_exists_depth_to depth x φ
depth: nat
dbi: db_index
maximal_exists_depth_to depth x
  φ^[svar:S dbi↦patt_free_svar X] =
maximal_exists_depth_to depth x φ
    1-2: now rewrite IHφ1; rewrite IHφ2.
Σ: Signature
φ: Pattern
x: evar
X: svar
IHφ: ∀ (depth : nat) (dbi : db_index),
maximal_exists_depth_to depth x φ^{svar:dbi↦X} =
maximal_exists_depth_to depth x φ
depth: nat
dbi: db_index
maximal_exists_depth_to (S depth) x
  φ^[svar:dbi↦patt_free_svar X] =
maximal_exists_depth_to (S depth) x φ
Σ: Signature
φ: Pattern
x: evar
X: svar
IHφ: ∀ (depth : nat) (dbi : db_index),
  maximal_exists_depth_to depth x φ^{svar:dbi↦X} =
  maximal_exists_depth_to depth x φ
depth: nat
dbi: db_index
maximal_exists_depth_to depth x
  φ^[svar:S dbi↦patt_free_svar X] =
maximal_exists_depth_to depth x φ
    now rewrite IHφ.
Σ: Signature
φ: Pattern
x: evar
X: svar
IHφ: ∀ (depth : nat) (dbi : db_index),
maximal_exists_depth_to depth x φ^{svar:dbi↦X} =
maximal_exists_depth_to depth x φ
depth: nat
dbi: db_index
maximal_exists_depth_to depth x
  φ^[svar:S dbi↦patt_free_svar X] =
maximal_exists_depth_to depth x φ
    now rewrite IHφ.
  Qed.

  Fixpoint maximal_mu_depth_to (depth : nat) (E : evar) (ψ : Pattern) : nat :=
    match ψ with
    | patt_bott => 0
    | patt_sym _ => 0
    | patt_bound_evar _ => 0
    | patt_bound_svar _ => 0
    | patt_free_svar _ => 0
    | patt_free_evar E' =>
      match (decide (E' = E)) with
      | left _ => depth
      | right _ => 0
      end
    | patt_imp ψ₁ ψ₂
      => Nat.max
        (maximal_mu_depth_to depth E ψ₁)
        (maximal_mu_depth_to depth E ψ₂)
    | patt_app ψ₁ ψ₂
      => Nat.max
        (maximal_mu_depth_to depth E ψ₁)
        (maximal_mu_depth_to depth E ψ₂)
    | patt_exists ψ' =>
      maximal_mu_depth_to depth E ψ'
    | patt_mu ψ' =>
      maximal_mu_depth_to (S depth) E ψ'
    end.

  Lemma maximal_mu_depth_to_svar_open depth E n X ψ:
  maximal_mu_depth_to depth E (ψ^{svar: n ↦ X})
    = maximal_mu_depth_to depth E ψ.
Σ: Signature
depth: nat
E: evar
n: db_index
X: svar
ψ: Pattern
maximal_mu_depth_to depth E ψ^{svar:n↦X} =
maximal_mu_depth_to depth E ψ
  Proof.
Σ: Signature
depth: nat
E: evar
n: db_index
X: svar
ψ: Pattern
maximal_mu_depth_to depth E ψ^{svar:n↦X} =
maximal_mu_depth_to depth E ψ
    unfold svar_open.
Σ: Signature
depth: nat
E: evar
n: db_index
X: svar
ψ: Pattern
maximal_mu_depth_to depth E
  ψ^[svar:n↦patt_free_svar X] =
maximal_mu_depth_to depth E ψ
    move: depth n.
Σ: Signature
E: evar
X: svar
ψ: Pattern
∀ (depth : nat) (n : db_index),
  maximal_mu_depth_to depth E
    ψ^[svar:n↦patt_free_svar X] =
  maximal_mu_depth_to depth E ψ
    induction ψ; intros depth n'; simpl; try reflexivity; auto.
Σ: Signature
E: evar
X: svar
n: db_index
depth: nat
n': db_index
maximal_mu_depth_to depth E
  match compare_nat n n' with
  | Nat_less _ _ _ => patt_bound_svar n
  | Nat_equal _ _ _ => patt_free_svar X
  | Nat_greater _ _ _ => patt_bound_svar (Nat.pred n)
  end = 0
    {
Σ: Signature
E: evar
X: svar
n: db_index
depth: nat
n': db_index
maximal_mu_depth_to depth E
  match compare_nat n n' with
  | Nat_less _ _ _ => patt_bound_svar n
  | Nat_equal _ _ _ => patt_free_svar X
  | Nat_greater _ _ _ => patt_bound_svar (Nat.pred n)
  end = 0
      case_match; simpl; try reflexivity.
    }
  Qed.

  Lemma evar_open_mu_depth depth E n x ψ:
    E <> x ->
    maximal_mu_depth_to depth E (ψ^{evar: n ↦ x})
    = maximal_mu_depth_to depth E ψ.
Σ: Signature
depth: nat
E: evar
n: db_index
x: evar
ψ: Pattern
E ≠ x
→ maximal_mu_depth_to depth E ψ^{evar:n↦x} =
  maximal_mu_depth_to depth E ψ
  Proof.
Σ: Signature
depth: nat
E: evar
n: db_index
x: evar
ψ: Pattern
E ≠ x
→ maximal_mu_depth_to depth E ψ^{evar:n↦x} =
  maximal_mu_depth_to depth E ψ
    intros Hne.
Σ: Signature
depth: nat
E: evar
n: db_index
x: evar
ψ: Pattern
Hne: E ≠ x
maximal_mu_depth_to depth E ψ^{evar:n↦x} =
maximal_mu_depth_to depth E ψ
    unfold evar_open.
Σ: Signature
depth: nat
E: evar
n: db_index
x: evar
ψ: Pattern
Hne: E ≠ x
maximal_mu_depth_to depth E
  ψ^[evar:n↦patt_free_evar x] =
maximal_mu_depth_to depth E ψ
    move: depth n.
Σ: Signature
E, x: evar
ψ: Pattern
Hne: E ≠ x
∀ (depth : nat) (n : db_index),
  maximal_mu_depth_to depth E
    ψ^[evar:n↦patt_free_evar x] =
  maximal_mu_depth_to depth E ψ
    induction ψ; intros depth n'; simpl; try reflexivity; auto.
Σ: Signature
E, x: evar
n: db_index
Hne: E ≠ x
depth: nat
n': db_index
maximal_mu_depth_to depth E
  match compare_nat n n' with
  | Nat_less _ _ _ => patt_bound_evar n
  | Nat_equal _ _ _ => patt_free_evar x
  | Nat_greater _ _ _ => patt_bound_evar (Nat.pred n)
  end = 0
    {
Σ: Signature
E, x: evar
n: db_index
Hne: E ≠ x
depth: nat
n': db_index
maximal_mu_depth_to depth E
  match compare_nat n n' with
  | Nat_less _ _ _ => patt_bound_evar n
  | Nat_equal _ _ _ => patt_free_evar x
  | Nat_greater _ _ _ => patt_bound_evar (Nat.pred n)
  end = 0
      case_match; simpl; try reflexivity.
Σ: Signature
E, x: evar
n: db_index
Hne: E ≠ x
depth: nat
n': db_index
e: n = n'
H: compare_nat n n' = Nat_equal n n' e
(if decide (x = E) then depth else 0) = 0
      case_match; simpl; try reflexivity.
Σ: Signature
E, x: evar
n: db_index
Hne: E ≠ x
depth: nat
n': db_index
e: n = n'
H: compare_nat n n' = Nat_equal n n' e
e0: x = E
H0: decide (x = E) = left e0
depth = 0
      subst.
Σ: Signature
E: evar
Hne: E ≠ E
depth: nat
n': db_index
H: compare_nat n' n' = Nat_equal n' n' erefl
H0: decide (E = E) = left erefl
depth = 0 contradiction.
    }
  Qed.

  Lemma svar_open_mu_depth depth E n X ψ:
    maximal_mu_depth_to depth E (ψ^{svar: n ↦ X})
    = maximal_mu_depth_to depth E ψ.
Σ: Signature
depth: nat
E: evar
n: db_index
X: svar
ψ: Pattern
maximal_mu_depth_to depth E ψ^{svar:n↦X} =
maximal_mu_depth_to depth E ψ
  Proof.
Σ: Signature
depth: nat
E: evar
n: db_index
X: svar
ψ: Pattern
maximal_mu_depth_to depth E ψ^{svar:n↦X} =
maximal_mu_depth_to depth E ψ
    unfold svar_open.
Σ: Signature
depth: nat
E: evar
n: db_index
X: svar
ψ: Pattern
maximal_mu_depth_to depth E
  ψ^[svar:n↦patt_free_svar X] =
maximal_mu_depth_to depth E ψ
    move: depth n.
Σ: Signature
E: evar
X: svar
ψ: Pattern
∀ (depth : nat) (n : db_index),
  maximal_mu_depth_to depth E
    ψ^[svar:n↦patt_free_svar X] =
  maximal_mu_depth_to depth E ψ
    induction ψ; intros depth n'; simpl; try reflexivity; auto.
Σ: Signature
E: evar
X: svar
n: db_index
depth: nat
n': db_index
maximal_mu_depth_to depth E
  match compare_nat n n' with
  | Nat_less _ _ _ => patt_bound_svar n
  | Nat_equal _ _ _ => patt_free_svar X
  | Nat_greater _ _ _ => patt_bound_svar (Nat.pred n)
  end = 0
    {
Σ: Signature
E: evar
X: svar
n: db_index
depth: nat
n': db_index
maximal_mu_depth_to depth E
  match compare_nat n n' with
  | Nat_less _ _ _ => patt_bound_svar n
  | Nat_equal _ _ _ => patt_free_svar X
  | Nat_greater _ _ _ => patt_bound_svar (Nat.pred n)
  end = 0
      case_match; simpl; try reflexivity.
    }
  Qed.

  Lemma maximal_mu_depth_to_0 E ψ depth:
    E ∉ free_evars ψ ->
    maximal_mu_depth_to depth E ψ = 0.
Σ: Signature
E: evar
ψ: Pattern
depth: nat
E ∉ free_evars ψ → maximal_mu_depth_to depth E ψ = 0
  Proof.
Σ: Signature
E: evar
ψ: Pattern
depth: nat
E ∉ free_evars ψ → maximal_mu_depth_to depth E ψ = 0
    intros Hnotin.
Σ: Signature
E: evar
ψ: Pattern
depth: nat
Hnotin: E ∉ free_evars ψ
maximal_mu_depth_to depth E ψ = 0
    move: E depth Hnotin.
Σ: Signature
ψ: Pattern
∀ (E : evar) (depth : nat),
  E ∉ free_evars ψ → maximal_mu_depth_to depth E ψ = 0
    induction ψ; intros E depth Hnotin; simpl in *; try reflexivity.
Σ: Signature
x, E: evar
depth: nat
Hnotin: E ∉ {[x]}
(if decide (x = E) then depth else 0) = 0
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: ∀ (E : evar) (depth : nat),
  E ∉ free_evars ψ1
  → maximal_mu_depth_to depth E ψ1 = 0
IHψ2: ∀ (E : evar) (depth : nat),
  E ∉ free_evars ψ2
  → maximal_mu_depth_to depth E ψ2 = 0
E: evar
depth: nat
Hnotin: E ∉ free_evars ψ1 ∪ free_evars ψ2
maximal_mu_depth_to depth E ψ1
`max` maximal_mu_depth_to depth E ψ2 = 0
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: ∀ (E : evar) (depth : nat),
  E ∉ free_evars ψ1
  → maximal_mu_depth_to depth E ψ1 = 0
IHψ2: ∀ (E : evar) (depth : nat),
  E ∉ free_evars ψ2
  → maximal_mu_depth_to depth E ψ2 = 0
E: evar
depth: nat
Hnotin: E ∉ free_evars ψ1 ∪ free_evars ψ2
maximal_mu_depth_to depth E ψ1
`max` maximal_mu_depth_to depth E ψ2 = 0
Σ: Signature
ψ: Pattern
IHψ: ∀ (E : evar) (depth : nat),
  E ∉ free_evars ψ
  → maximal_mu_depth_to depth E ψ = 0
E: evar
depth: nat
Hnotin: E ∉ free_evars ψ
maximal_mu_depth_to depth E ψ = 0
Σ: Signature
ψ: Pattern
IHψ: ∀ (E : evar) (depth : nat),
  E ∉ free_evars ψ
  → maximal_mu_depth_to depth E ψ = 0
E: evar
depth: nat
Hnotin: E ∉ free_evars ψ
maximal_mu_depth_to (S depth) E ψ = 0
    {
Σ: Signature
x, E: evar
depth: nat
Hnotin: E ∉ {[x]}
(if decide (x = E) then depth else 0) = 0 case_match.
Σ: Signature
x, E: evar
depth: nat
Hnotin: E ∉ {[x]}
e: x = E
H: decide (x = E) = left e
depth = 0
Σ: Signature
x, E: evar
depth: nat
Hnotin: E ∉ {[x]}
n: x ≠ E
H: decide (x = E) = right n
0 = 0 set_solver.
Σ: Signature
x, E: evar
depth: nat
Hnotin: E ∉ {[x]}
n: x ≠ E
H: decide (x = E) = right n
0 = 0 reflexivity. }
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: ∀ (E : evar) (depth : nat),
  E ∉ free_evars ψ1
  → maximal_mu_depth_to depth E ψ1 = 0
IHψ2: ∀ (E : evar) (depth : nat),
  E ∉ free_evars ψ2
  → maximal_mu_depth_to depth E ψ2 = 0
E: evar
depth: nat
Hnotin: E ∉ free_evars ψ1 ∪ free_evars ψ2
maximal_mu_depth_to depth E ψ1
`max` maximal_mu_depth_to depth E ψ2 = 0
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: ∀ (E : evar) (depth : nat),
  E ∉ free_evars ψ1
  → maximal_mu_depth_to depth E ψ1 = 0
IHψ2: ∀ (E : evar) (depth : nat),
  E ∉ free_evars ψ2
  → maximal_mu_depth_to depth E ψ2 = 0
E: evar
depth: nat
Hnotin: E ∉ free_evars ψ1 ∪ free_evars ψ2
maximal_mu_depth_to depth E ψ1
`max` maximal_mu_depth_to depth E ψ2 = 0
Σ: Signature
ψ: Pattern
IHψ: ∀ (E : evar) (depth : nat),
  E ∉ free_evars ψ
  → maximal_mu_depth_to depth E ψ = 0
E: evar
depth: nat
Hnotin: E ∉ free_evars ψ
maximal_mu_depth_to depth E ψ = 0
Σ: Signature
ψ: Pattern
IHψ: ∀ (E : evar) (depth : nat),
  E ∉ free_evars ψ
  → maximal_mu_depth_to depth E ψ = 0
E: evar
depth: nat
Hnotin: E ∉ free_evars ψ
maximal_mu_depth_to (S depth) E ψ = 0
    {
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: ∀ (E : evar) (depth : nat),
  E ∉ free_evars ψ1
  → maximal_mu_depth_to depth E ψ1 = 0
IHψ2: ∀ (E : evar) (depth : nat),
  E ∉ free_evars ψ2
  → maximal_mu_depth_to depth E ψ2 = 0
E: evar
depth: nat
Hnotin: E ∉ free_evars ψ1 ∪ free_evars ψ2
maximal_mu_depth_to depth E ψ1
`max` maximal_mu_depth_to depth E ψ2 = 0 rewrite IHψ1.
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: ∀ (E : evar) (depth : nat),
  E ∉ free_evars ψ1
  → maximal_mu_depth_to depth E ψ1 = 0
IHψ2: ∀ (E : evar) (depth : nat),
  E ∉ free_evars ψ2
  → maximal_mu_depth_to depth E ψ2 = 0
E: evar
depth: nat
Hnotin: E ∉ free_evars ψ1 ∪ free_evars ψ2
E ∉ free_evars ψ1
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: ∀ (E : evar) (depth : nat),
  E ∉ free_evars ψ1
  → maximal_mu_depth_to depth E ψ1 = 0
IHψ2: ∀ (E : evar) (depth : nat),
  E ∉ free_evars ψ2
  → maximal_mu_depth_to depth E ψ2 = 0
E: evar
depth: nat
Hnotin: E ∉ free_evars ψ1 ∪ free_evars ψ2
0 `max` maximal_mu_depth_to depth E ψ2 = 0 set_solver.
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: ∀ (E : evar) (depth : nat),
  E ∉ free_evars ψ1
  → maximal_mu_depth_to depth E ψ1 = 0
IHψ2: ∀ (E : evar) (depth : nat),
  E ∉ free_evars ψ2
  → maximal_mu_depth_to depth E ψ2 = 0
E: evar
depth: nat
Hnotin: E ∉ free_evars ψ1 ∪ free_evars ψ2
0 `max` maximal_mu_depth_to depth E ψ2 = 0 rewrite IHψ2.
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: ∀ (E : evar) (depth : nat),
  E ∉ free_evars ψ1
  → maximal_mu_depth_to depth E ψ1 = 0
IHψ2: ∀ (E : evar) (depth : nat),
  E ∉ free_evars ψ2
  → maximal_mu_depth_to depth E ψ2 = 0
E: evar
depth: nat
Hnotin: E ∉ free_evars ψ1 ∪ free_evars ψ2
E ∉ free_evars ψ2
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: ∀ (E : evar) (depth : nat),
  E ∉ free_evars ψ1
  → maximal_mu_depth_to depth E ψ1 = 0
IHψ2: ∀ (E : evar) (depth : nat),
  E ∉ free_evars ψ2
  → maximal_mu_depth_to depth E ψ2 = 0
E: evar
depth: nat
Hnotin: E ∉ free_evars ψ1 ∪ free_evars ψ2
0 `max` 0 = 0 set_solver.
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: ∀ (E : evar) (depth : nat),
  E ∉ free_evars ψ1
  → maximal_mu_depth_to depth E ψ1 = 0
IHψ2: ∀ (E : evar) (depth : nat),
  E ∉ free_evars ψ2
  → maximal_mu_depth_to depth E ψ2 = 0
E: evar
depth: nat
Hnotin: E ∉ free_evars ψ1 ∪ free_evars ψ2
0 `max` 0 = 0 reflexivity. }
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: ∀ (E : evar) (depth : nat),
  E ∉ free_evars ψ1
  → maximal_mu_depth_to depth E ψ1 = 0
IHψ2: ∀ (E : evar) (depth : nat),
  E ∉ free_evars ψ2
  → maximal_mu_depth_to depth E ψ2 = 0
E: evar
depth: nat
Hnotin: E ∉ free_evars ψ1 ∪ free_evars ψ2
maximal_mu_depth_to depth E ψ1
`max` maximal_mu_depth_to depth E ψ2 = 0
Σ: Signature
ψ: Pattern
IHψ: ∀ (E : evar) (depth : nat),
  E ∉ free_evars ψ
  → maximal_mu_depth_to depth E ψ = 0
E: evar
depth: nat
Hnotin: E ∉ free_evars ψ
maximal_mu_depth_to depth E ψ = 0
Σ: Signature
ψ: Pattern
IHψ: ∀ (E : evar) (depth : nat),
  E ∉ free_evars ψ
  → maximal_mu_depth_to depth E ψ = 0
E: evar
depth: nat
Hnotin: E ∉ free_evars ψ
maximal_mu_depth_to (S depth) E ψ = 0
    {
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: ∀ (E : evar) (depth : nat),
  E ∉ free_evars ψ1
  → maximal_mu_depth_to depth E ψ1 = 0
IHψ2: ∀ (E : evar) (depth : nat),
  E ∉ free_evars ψ2
  → maximal_mu_depth_to depth E ψ2 = 0
E: evar
depth: nat
Hnotin: E ∉ free_evars ψ1 ∪ free_evars ψ2
maximal_mu_depth_to depth E ψ1
`max` maximal_mu_depth_to depth E ψ2 = 0 rewrite IHψ1.
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: ∀ (E : evar) (depth : nat),
  E ∉ free_evars ψ1
  → maximal_mu_depth_to depth E ψ1 = 0
IHψ2: ∀ (E : evar) (depth : nat),
  E ∉ free_evars ψ2
  → maximal_mu_depth_to depth E ψ2 = 0
E: evar
depth: nat
Hnotin: E ∉ free_evars ψ1 ∪ free_evars ψ2
E ∉ free_evars ψ1
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: ∀ (E : evar) (depth : nat),
  E ∉ free_evars ψ1
  → maximal_mu_depth_to depth E ψ1 = 0
IHψ2: ∀ (E : evar) (depth : nat),
  E ∉ free_evars ψ2
  → maximal_mu_depth_to depth E ψ2 = 0
E: evar
depth: nat
Hnotin: E ∉ free_evars ψ1 ∪ free_evars ψ2
0 `max` maximal_mu_depth_to depth E ψ2 = 0 set_solver.
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: ∀ (E : evar) (depth : nat),
  E ∉ free_evars ψ1
  → maximal_mu_depth_to depth E ψ1 = 0
IHψ2: ∀ (E : evar) (depth : nat),
  E ∉ free_evars ψ2
  → maximal_mu_depth_to depth E ψ2 = 0
E: evar
depth: nat
Hnotin: E ∉ free_evars ψ1 ∪ free_evars ψ2
0 `max` maximal_mu_depth_to depth E ψ2 = 0 rewrite IHψ2.
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: ∀ (E : evar) (depth : nat),
  E ∉ free_evars ψ1
  → maximal_mu_depth_to depth E ψ1 = 0
IHψ2: ∀ (E : evar) (depth : nat),
  E ∉ free_evars ψ2
  → maximal_mu_depth_to depth E ψ2 = 0
E: evar
depth: nat
Hnotin: E ∉ free_evars ψ1 ∪ free_evars ψ2
E ∉ free_evars ψ2
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: ∀ (E : evar) (depth : nat),
  E ∉ free_evars ψ1
  → maximal_mu_depth_to depth E ψ1 = 0
IHψ2: ∀ (E : evar) (depth : nat),
  E ∉ free_evars ψ2
  → maximal_mu_depth_to depth E ψ2 = 0
E: evar
depth: nat
Hnotin: E ∉ free_evars ψ1 ∪ free_evars ψ2
0 `max` 0 = 0 set_solver.
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: ∀ (E : evar) (depth : nat),
  E ∉ free_evars ψ1
  → maximal_mu_depth_to depth E ψ1 = 0
IHψ2: ∀ (E : evar) (depth : nat),
  E ∉ free_evars ψ2
  → maximal_mu_depth_to depth E ψ2 = 0
E: evar
depth: nat
Hnotin: E ∉ free_evars ψ1 ∪ free_evars ψ2
0 `max` 0 = 0 reflexivity. }
Σ: Signature
ψ: Pattern
IHψ: ∀ (E : evar) (depth : nat),
E ∉ free_evars ψ → maximal_mu_depth_to depth E ψ = 0
E: evar
depth: nat
Hnotin: E ∉ free_evars ψ
maximal_mu_depth_to depth E ψ = 0
Σ: Signature
ψ: Pattern
IHψ: ∀ (E : evar) (depth : nat),
  E ∉ free_evars ψ
  → maximal_mu_depth_to depth E ψ = 0
E: evar
depth: nat
Hnotin: E ∉ free_evars ψ
maximal_mu_depth_to (S depth) E ψ = 0
    {
Σ: Signature
ψ: Pattern
IHψ: ∀ (E : evar) (depth : nat),
E ∉ free_evars ψ → maximal_mu_depth_to depth E ψ = 0
E: evar
depth: nat
Hnotin: E ∉ free_evars ψ
maximal_mu_depth_to depth E ψ = 0 rewrite IHψ.
Σ: Signature
ψ: Pattern
IHψ: ∀ (E : evar) (depth : nat),
E ∉ free_evars ψ → maximal_mu_depth_to depth E ψ = 0
E: evar
depth: nat
Hnotin: E ∉ free_evars ψ
E ∉ free_evars ψ
Σ: Signature
ψ: Pattern
IHψ: ∀ (E : evar) (depth : nat),
  E ∉ free_evars ψ
  → maximal_mu_depth_to depth E ψ = 0
E: evar
depth: nat
Hnotin: E ∉ free_evars ψ
0 = 0 exact Hnotin.
Σ: Signature
ψ: Pattern
IHψ: ∀ (E : evar) (depth : nat),
E ∉ free_evars ψ → maximal_mu_depth_to depth E ψ = 0
E: evar
depth: nat
Hnotin: E ∉ free_evars ψ
0 = 0 reflexivity. }
Σ: Signature
ψ: Pattern
IHψ: ∀ (E : evar) (depth : nat),
E ∉ free_evars ψ → maximal_mu_depth_to depth E ψ = 0
E: evar
depth: nat
Hnotin: E ∉ free_evars ψ
maximal_mu_depth_to (S depth) E ψ = 0
    {
Σ: Signature
ψ: Pattern
IHψ: ∀ (E : evar) (depth : nat),
E ∉ free_evars ψ → maximal_mu_depth_to depth E ψ = 0
E: evar
depth: nat
Hnotin: E ∉ free_evars ψ
maximal_mu_depth_to (S depth) E ψ = 0 rewrite IHψ.
Σ: Signature
ψ: Pattern
IHψ: ∀ (E : evar) (depth : nat),
E ∉ free_evars ψ → maximal_mu_depth_to depth E ψ = 0
E: evar
depth: nat
Hnotin: E ∉ free_evars ψ
E ∉ free_evars ψ
Σ: Signature
ψ: Pattern
IHψ: ∀ (E : evar) (depth : nat),
  E ∉ free_evars ψ
  → maximal_mu_depth_to depth E ψ = 0
E: evar
depth: nat
Hnotin: E ∉ free_evars ψ
0 = 0 exact Hnotin.
Σ: Signature
ψ: Pattern
IHψ: ∀ (E : evar) (depth : nat),
E ∉ free_evars ψ → maximal_mu_depth_to depth E ψ = 0
E: evar
depth: nat
Hnotin: E ∉ free_evars ψ
0 = 0 reflexivity. }
  Qed.

  Lemma maximal_mu_depth_to_S E ψ depth:
    E ∈ free_evars ψ ->
    maximal_mu_depth_to (S depth) E ψ
    = S (maximal_mu_depth_to depth E ψ).
Σ: Signature
E: evar
ψ: Pattern
depth: nat
E ∈ free_evars ψ
→ maximal_mu_depth_to (S depth) E ψ =
  S (maximal_mu_depth_to depth E ψ)
  Proof.
Σ: Signature
E: evar
ψ: Pattern
depth: nat
E ∈ free_evars ψ
→ maximal_mu_depth_to (S depth) E ψ =
  S (maximal_mu_depth_to depth E ψ)
    intros Hin.
Σ: Signature
E: evar
ψ: Pattern
depth: nat
Hin: E ∈ free_evars ψ
maximal_mu_depth_to (S depth) E ψ =
S (maximal_mu_depth_to depth E ψ)
    move: E depth Hin.
Σ: Signature
ψ: Pattern
∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ
  → maximal_mu_depth_to (S depth) E ψ =
    S (maximal_mu_depth_to depth E ψ)
    induction ψ; intros E depth Hin; simpl in *; try set_solver.
Σ: Signature
x, E: evar
depth: nat
Hin: E ∈ {[x]}
(if decide (x = E) then S depth else 0) =
S (if decide (x = E) then depth else 0)
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ1
  → maximal_mu_depth_to (S depth) E ψ1 =
    S (maximal_mu_depth_to depth E ψ1)
IHψ2: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ2
  → maximal_mu_depth_to (S depth) E ψ2 =
    S (maximal_mu_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
maximal_mu_depth_to (S depth) E ψ1
`max` maximal_mu_depth_to (S depth) E ψ2 =
S
  (maximal_mu_depth_to depth E ψ1
   `max` maximal_mu_depth_to depth E ψ2)
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ1
  → maximal_mu_depth_to (S depth) E ψ1 =
    S (maximal_mu_depth_to depth E ψ1)
IHψ2: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ2
  → maximal_mu_depth_to (S depth) E ψ2 =
    S (maximal_mu_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
maximal_mu_depth_to (S depth) E ψ1
`max` maximal_mu_depth_to (S depth) E ψ2 =
S
  (maximal_mu_depth_to depth E ψ1
   `max` maximal_mu_depth_to depth E ψ2)
    {
Σ: Signature
x, E: evar
depth: nat
Hin: E ∈ {[x]}
(if decide (x = E) then S depth else 0) =
S (if decide (x = E) then depth else 0) case_match.
Σ: Signature
x, E: evar
depth: nat
Hin: E ∈ {[x]}
e: x = E
H: decide (x = E) = left e
S depth = S depth
Σ: Signature
x, E: evar
depth: nat
Hin: E ∈ {[x]}
n: x ≠ E
H: decide (x = E) = right n
0 = 1 reflexivity.
Σ: Signature
x, E: evar
depth: nat
Hin: E ∈ {[x]}
n: x ≠ E
H: decide (x = E) = right n
0 = 1 set_solver. }
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ1
  → maximal_mu_depth_to (S depth) E ψ1 =
    S (maximal_mu_depth_to depth E ψ1)
IHψ2: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ2
  → maximal_mu_depth_to (S depth) E ψ2 =
    S (maximal_mu_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
maximal_mu_depth_to (S depth) E ψ1
`max` maximal_mu_depth_to (S depth) E ψ2 =
S
  (maximal_mu_depth_to depth E ψ1
   `max` maximal_mu_depth_to depth E ψ2)
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ1
  → maximal_mu_depth_to (S depth) E ψ1 =
    S (maximal_mu_depth_to depth E ψ1)
IHψ2: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ2
  → maximal_mu_depth_to (S depth) E ψ2 =
    S (maximal_mu_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
maximal_mu_depth_to (S depth) E ψ1
`max` maximal_mu_depth_to (S depth) E ψ2 =
S
  (maximal_mu_depth_to depth E ψ1
   `max` maximal_mu_depth_to depth E ψ2)
    {
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ1
  → maximal_mu_depth_to (S depth) E ψ1 =
    S (maximal_mu_depth_to depth E ψ1)
IHψ2: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ2
  → maximal_mu_depth_to (S depth) E ψ2 =
    S (maximal_mu_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
maximal_mu_depth_to (S depth) E ψ1
`max` maximal_mu_depth_to (S depth) E ψ2 =
S
  (maximal_mu_depth_to depth E ψ1
   `max` maximal_mu_depth_to depth E ψ2)
      destruct (decide (E ∈ free_evars ψ1)),(decide (E ∈ free_evars ψ2)).
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ1
  → maximal_mu_depth_to (S depth) E ψ1 =
    S (maximal_mu_depth_to depth E ψ1)
IHψ2: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ2
  → maximal_mu_depth_to (S depth) E ψ2 =
    S (maximal_mu_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
e: E ∈ free_evars ψ1
e0: E ∈ free_evars ψ2
maximal_mu_depth_to (S depth) E ψ1
`max` maximal_mu_depth_to (S depth) E ψ2 =
S
  (maximal_mu_depth_to depth E ψ1
   `max` maximal_mu_depth_to depth E ψ2)
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ1
  → maximal_mu_depth_to (S depth) E ψ1 =
    S (maximal_mu_depth_to depth E ψ1)
IHψ2: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ2
  → maximal_mu_depth_to (S depth) E ψ2 =
    S (maximal_mu_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
e: E ∈ free_evars ψ1
n: E ∉ free_evars ψ2
maximal_mu_depth_to (S depth) E ψ1
`max` maximal_mu_depth_to (S depth) E ψ2 =
S
  (maximal_mu_depth_to depth E ψ1
   `max` maximal_mu_depth_to depth E ψ2)
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ1
  → maximal_mu_depth_to (S depth) E ψ1 =
    S (maximal_mu_depth_to depth E ψ1)
IHψ2: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ2
  → maximal_mu_depth_to (S depth) E ψ2 =
    S (maximal_mu_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
n: E ∉ free_evars ψ1
e: E ∈ free_evars ψ2
maximal_mu_depth_to (S depth) E ψ1
`max` maximal_mu_depth_to (S depth) E ψ2 =
S
  (maximal_mu_depth_to depth E ψ1
   `max` maximal_mu_depth_to depth E ψ2)
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ1
  → maximal_mu_depth_to (S depth) E ψ1 =
    S (maximal_mu_depth_to depth E ψ1)
IHψ2: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ2
  → maximal_mu_depth_to (S depth) E ψ2 =
    S (maximal_mu_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
n: E ∉ free_evars ψ1
n0: E ∉ free_evars ψ2
maximal_mu_depth_to (S depth) E ψ1
`max` maximal_mu_depth_to (S depth) E ψ2 =
S
  (maximal_mu_depth_to depth E ψ1
   `max` maximal_mu_depth_to depth E ψ2)
      {
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ1
  → maximal_mu_depth_to (S depth) E ψ1 =
    S (maximal_mu_depth_to depth E ψ1)
IHψ2: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ2
  → maximal_mu_depth_to (S depth) E ψ2 =
    S (maximal_mu_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
e: E ∈ free_evars ψ1
e0: E ∈ free_evars ψ2
maximal_mu_depth_to (S depth) E ψ1
`max` maximal_mu_depth_to (S depth) E ψ2 =
S
  (maximal_mu_depth_to depth E ψ1
   `max` maximal_mu_depth_to depth E ψ2)
        rewrite IHψ1.
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ1
  → maximal_mu_depth_to (S depth) E ψ1 =
    S (maximal_mu_depth_to depth E ψ1)
IHψ2: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ2
  → maximal_mu_depth_to (S depth) E ψ2 =
    S (maximal_mu_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
e: E ∈ free_evars ψ1
e0: E ∈ free_evars ψ2
E ∈ free_evars ψ1
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ1
  → maximal_mu_depth_to (S depth) E ψ1 =
    S (maximal_mu_depth_to depth E ψ1)
IHψ2: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ2
  → maximal_mu_depth_to (S depth) E ψ2 =
    S (maximal_mu_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
e: E ∈ free_evars ψ1
e0: E ∈ free_evars ψ2
S (maximal_mu_depth_to depth E ψ1)
`max` maximal_mu_depth_to (S depth) E ψ2 =
S
  (maximal_mu_depth_to depth E ψ1
   `max` maximal_mu_depth_to depth E ψ2) assumption.
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ1
  → maximal_mu_depth_to (S depth) E ψ1 =
    S (maximal_mu_depth_to depth E ψ1)
IHψ2: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ2
  → maximal_mu_depth_to (S depth) E ψ2 =
    S (maximal_mu_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
e: E ∈ free_evars ψ1
e0: E ∈ free_evars ψ2
S (maximal_mu_depth_to depth E ψ1)
`max` maximal_mu_depth_to (S depth) E ψ2 =
S
  (maximal_mu_depth_to depth E ψ1
   `max` maximal_mu_depth_to depth E ψ2) rewrite IHψ2.
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ1
  → maximal_mu_depth_to (S depth) E ψ1 =
    S (maximal_mu_depth_to depth E ψ1)
IHψ2: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ2
  → maximal_mu_depth_to (S depth) E ψ2 =
    S (maximal_mu_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
e: E ∈ free_evars ψ1
e0: E ∈ free_evars ψ2
E ∈ free_evars ψ2
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ1
  → maximal_mu_depth_to (S depth) E ψ1 =
    S (maximal_mu_depth_to depth E ψ1)
IHψ2: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ2
  → maximal_mu_depth_to (S depth) E ψ2 =
    S (maximal_mu_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
e: E ∈ free_evars ψ1
e0: E ∈ free_evars ψ2
S (maximal_mu_depth_to depth E ψ1)
`max` S (maximal_mu_depth_to depth E ψ2) =
S
  (maximal_mu_depth_to depth E ψ1
   `max` maximal_mu_depth_to depth E ψ2) assumption.
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ1
  → maximal_mu_depth_to (S depth) E ψ1 =
    S (maximal_mu_depth_to depth E ψ1)
IHψ2: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ2
  → maximal_mu_depth_to (S depth) E ψ2 =
    S (maximal_mu_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
e: E ∈ free_evars ψ1
e0: E ∈ free_evars ψ2
S (maximal_mu_depth_to depth E ψ1)
`max` S (maximal_mu_depth_to depth E ψ2) =
S
  (maximal_mu_depth_to depth E ψ1
   `max` maximal_mu_depth_to depth E ψ2) simpl.
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ1
  → maximal_mu_depth_to (S depth) E ψ1 =
    S (maximal_mu_depth_to depth E ψ1)
IHψ2: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ2
  → maximal_mu_depth_to (S depth) E ψ2 =
    S (maximal_mu_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
e: E ∈ free_evars ψ1
e0: E ∈ free_evars ψ2
S
  (maximal_mu_depth_to depth E ψ1
   `max` maximal_mu_depth_to depth E ψ2) =
S
  (maximal_mu_depth_to depth E ψ1
   `max` maximal_mu_depth_to depth E ψ2) reflexivity.
      }
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ1
  → maximal_mu_depth_to (S depth) E ψ1 =
    S (maximal_mu_depth_to depth E ψ1)
IHψ2: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ2
  → maximal_mu_depth_to (S depth) E ψ2 =
    S (maximal_mu_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
e: E ∈ free_evars ψ1
n: E ∉ free_evars ψ2
maximal_mu_depth_to (S depth) E ψ1
`max` maximal_mu_depth_to (S depth) E ψ2 =
S
  (maximal_mu_depth_to depth E ψ1
   `max` maximal_mu_depth_to depth E ψ2)
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ1
  → maximal_mu_depth_to (S depth) E ψ1 =
    S (maximal_mu_depth_to depth E ψ1)
IHψ2: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ2
  → maximal_mu_depth_to (S depth) E ψ2 =
    S (maximal_mu_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
n: E ∉ free_evars ψ1
e: E ∈ free_evars ψ2
maximal_mu_depth_to (S depth) E ψ1
`max` maximal_mu_depth_to (S depth) E ψ2 =
S
  (maximal_mu_depth_to depth E ψ1
   `max` maximal_mu_depth_to depth E ψ2)
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ1
  → maximal_mu_depth_to (S depth) E ψ1 =
    S (maximal_mu_depth_to depth E ψ1)
IHψ2: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ2
  → maximal_mu_depth_to (S depth) E ψ2 =
    S (maximal_mu_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
n: E ∉ free_evars ψ1
n0: E ∉ free_evars ψ2
maximal_mu_depth_to (S depth) E ψ1
`max` maximal_mu_depth_to (S depth) E ψ2 =
S
  (maximal_mu_depth_to depth E ψ1
   `max` maximal_mu_depth_to depth E ψ2)
      {
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ1
  → maximal_mu_depth_to (S depth) E ψ1 =
    S (maximal_mu_depth_to depth E ψ1)
IHψ2: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ2
  → maximal_mu_depth_to (S depth) E ψ2 =
    S (maximal_mu_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
e: E ∈ free_evars ψ1
n: E ∉ free_evars ψ2
maximal_mu_depth_to (S depth) E ψ1
`max` maximal_mu_depth_to (S depth) E ψ2 =
S
  (maximal_mu_depth_to depth E ψ1
   `max` maximal_mu_depth_to depth E ψ2)
        rewrite IHψ1.
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ1
  → maximal_mu_depth_to (S depth) E ψ1 =
    S (maximal_mu_depth_to depth E ψ1)
IHψ2: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ2
  → maximal_mu_depth_to (S depth) E ψ2 =
    S (maximal_mu_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
e: E ∈ free_evars ψ1
n: E ∉ free_evars ψ2
E ∈ free_evars ψ1
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ1
  → maximal_mu_depth_to (S depth) E ψ1 =
    S (maximal_mu_depth_to depth E ψ1)
IHψ2: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ2
  → maximal_mu_depth_to (S depth) E ψ2 =
    S (maximal_mu_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
e: E ∈ free_evars ψ1
n: E ∉ free_evars ψ2
S (maximal_mu_depth_to depth E ψ1)
`max` maximal_mu_depth_to (S depth) E ψ2 =
S
  (maximal_mu_depth_to depth E ψ1
   `max` maximal_mu_depth_to depth E ψ2) assumption.
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ1
  → maximal_mu_depth_to (S depth) E ψ1 =
    S (maximal_mu_depth_to depth E ψ1)
IHψ2: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ2
  → maximal_mu_depth_to (S depth) E ψ2 =
    S (maximal_mu_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
e: E ∈ free_evars ψ1
n: E ∉ free_evars ψ2
S (maximal_mu_depth_to depth E ψ1)
`max` maximal_mu_depth_to (S depth) E ψ2 =
S
  (maximal_mu_depth_to depth E ψ1
   `max` maximal_mu_depth_to depth E ψ2)
        apply maximal_mu_depth_to_0 with (depth := S depth) in n
          as n'.
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ1
  → maximal_mu_depth_to (S depth) E ψ1 =
    S (maximal_mu_depth_to depth E ψ1)
IHψ2: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ2
  → maximal_mu_depth_to (S depth) E ψ2 =
    S (maximal_mu_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
e: E ∈ free_evars ψ1
n: E ∉ free_evars ψ2
n': maximal_mu_depth_to (S depth) E ψ2 = 0
S (maximal_mu_depth_to depth E ψ1)
`max` maximal_mu_depth_to (S depth) E ψ2 =
S
  (maximal_mu_depth_to depth E ψ1
   `max` maximal_mu_depth_to depth E ψ2)
        apply maximal_mu_depth_to_0 with (depth := depth) in n.
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ1
  → maximal_mu_depth_to (S depth) E ψ1 =
    S (maximal_mu_depth_to depth E ψ1)
IHψ2: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ2
  → maximal_mu_depth_to (S depth) E ψ2 =
    S (maximal_mu_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
e: E ∈ free_evars ψ1
n: maximal_mu_depth_to depth E ψ2 = 0
n': maximal_mu_depth_to (S depth) E ψ2 = 0
S (maximal_mu_depth_to depth E ψ1)
`max` maximal_mu_depth_to (S depth) E ψ2 =
S
  (maximal_mu_depth_to depth E ψ1
   `max` maximal_mu_depth_to depth E ψ2)
        rewrite n.
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ1
  → maximal_mu_depth_to (S depth) E ψ1 =
    S (maximal_mu_depth_to depth E ψ1)
IHψ2: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ2
  → maximal_mu_depth_to (S depth) E ψ2 =
    S (maximal_mu_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
e: E ∈ free_evars ψ1
n: maximal_mu_depth_to depth E ψ2 = 0
n': maximal_mu_depth_to (S depth) E ψ2 = 0
S (maximal_mu_depth_to depth E ψ1)
`max` maximal_mu_depth_to (S depth) E ψ2 =
S (maximal_mu_depth_to depth E ψ1 `max` 0) lia. 
      }
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ1
  → maximal_mu_depth_to (S depth) E ψ1 =
    S (maximal_mu_depth_to depth E ψ1)
IHψ2: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ2
  → maximal_mu_depth_to (S depth) E ψ2 =
    S (maximal_mu_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
n: E ∉ free_evars ψ1
e: E ∈ free_evars ψ2
maximal_mu_depth_to (S depth) E ψ1
`max` maximal_mu_depth_to (S depth) E ψ2 =
S
  (maximal_mu_depth_to depth E ψ1
   `max` maximal_mu_depth_to depth E ψ2)
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ1
  → maximal_mu_depth_to (S depth) E ψ1 =
    S (maximal_mu_depth_to depth E ψ1)
IHψ2: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ2
  → maximal_mu_depth_to (S depth) E ψ2 =
    S (maximal_mu_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
n: E ∉ free_evars ψ1
n0: E ∉ free_evars ψ2
maximal_mu_depth_to (S depth) E ψ1
`max` maximal_mu_depth_to (S depth) E ψ2 =
S
  (maximal_mu_depth_to depth E ψ1
   `max` maximal_mu_depth_to depth E ψ2)
      {
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ1
  → maximal_mu_depth_to (S depth) E ψ1 =
    S (maximal_mu_depth_to depth E ψ1)
IHψ2: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ2
  → maximal_mu_depth_to (S depth) E ψ2 =
    S (maximal_mu_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
n: E ∉ free_evars ψ1
e: E ∈ free_evars ψ2
maximal_mu_depth_to (S depth) E ψ1
`max` maximal_mu_depth_to (S depth) E ψ2 =
S
  (maximal_mu_depth_to depth E ψ1
   `max` maximal_mu_depth_to depth E ψ2)
        rewrite IHψ2.
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ1
  → maximal_mu_depth_to (S depth) E ψ1 =
    S (maximal_mu_depth_to depth E ψ1)
IHψ2: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ2
  → maximal_mu_depth_to (S depth) E ψ2 =
    S (maximal_mu_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
n: E ∉ free_evars ψ1
e: E ∈ free_evars ψ2
E ∈ free_evars ψ2
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ1
  → maximal_mu_depth_to (S depth) E ψ1 =
    S (maximal_mu_depth_to depth E ψ1)
IHψ2: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ2
  → maximal_mu_depth_to (S depth) E ψ2 =
    S (maximal_mu_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
n: E ∉ free_evars ψ1
e: E ∈ free_evars ψ2
maximal_mu_depth_to (S depth) E ψ1
`max` S (maximal_mu_depth_to depth E ψ2) =
S
  (maximal_mu_depth_to depth E ψ1
   `max` maximal_mu_depth_to depth E ψ2) assumption.
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ1
  → maximal_mu_depth_to (S depth) E ψ1 =
    S (maximal_mu_depth_to depth E ψ1)
IHψ2: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ2
  → maximal_mu_depth_to (S depth) E ψ2 =
    S (maximal_mu_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
n: E ∉ free_evars ψ1
e: E ∈ free_evars ψ2
maximal_mu_depth_to (S depth) E ψ1
`max` S (maximal_mu_depth_to depth E ψ2) =
S
  (maximal_mu_depth_to depth E ψ1
   `max` maximal_mu_depth_to depth E ψ2)
        apply maximal_mu_depth_to_0 with (depth := S depth) in n
          as n'.
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ1
  → maximal_mu_depth_to (S depth) E ψ1 =
    S (maximal_mu_depth_to depth E ψ1)
IHψ2: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ2
  → maximal_mu_depth_to (S depth) E ψ2 =
    S (maximal_mu_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
n: E ∉ free_evars ψ1
e: E ∈ free_evars ψ2
n': maximal_mu_depth_to (S depth) E ψ1 = 0
maximal_mu_depth_to (S depth) E ψ1
`max` S (maximal_mu_depth_to depth E ψ2) =
S
  (maximal_mu_depth_to depth E ψ1
   `max` maximal_mu_depth_to depth E ψ2)
        apply maximal_mu_depth_to_0 with (depth := depth) in n.
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ1
  → maximal_mu_depth_to (S depth) E ψ1 =
    S (maximal_mu_depth_to depth E ψ1)
IHψ2: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ2
  → maximal_mu_depth_to (S depth) E ψ2 =
    S (maximal_mu_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
n: maximal_mu_depth_to depth E ψ1 = 0
e: E ∈ free_evars ψ2
n': maximal_mu_depth_to (S depth) E ψ1 = 0
maximal_mu_depth_to (S depth) E ψ1
`max` S (maximal_mu_depth_to depth E ψ2) =
S
  (maximal_mu_depth_to depth E ψ1
   `max` maximal_mu_depth_to depth E ψ2)
        rewrite n.
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ1
  → maximal_mu_depth_to (S depth) E ψ1 =
    S (maximal_mu_depth_to depth E ψ1)
IHψ2: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ2
  → maximal_mu_depth_to (S depth) E ψ2 =
    S (maximal_mu_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
n: maximal_mu_depth_to depth E ψ1 = 0
e: E ∈ free_evars ψ2
n': maximal_mu_depth_to (S depth) E ψ1 = 0
maximal_mu_depth_to (S depth) E ψ1
`max` S (maximal_mu_depth_to depth E ψ2) =
S (0 `max` maximal_mu_depth_to depth E ψ2) lia. 
      }
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ1
  → maximal_mu_depth_to (S depth) E ψ1 =
    S (maximal_mu_depth_to depth E ψ1)
IHψ2: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ2
  → maximal_mu_depth_to (S depth) E ψ2 =
    S (maximal_mu_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
n: E ∉ free_evars ψ1
n0: E ∉ free_evars ψ2
maximal_mu_depth_to (S depth) E ψ1
`max` maximal_mu_depth_to (S depth) E ψ2 =
S
  (maximal_mu_depth_to depth E ψ1
   `max` maximal_mu_depth_to depth E ψ2)
      {
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ1
  → maximal_mu_depth_to (S depth) E ψ1 =
    S (maximal_mu_depth_to depth E ψ1)
IHψ2: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ2
  → maximal_mu_depth_to (S depth) E ψ2 =
    S (maximal_mu_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
n: E ∉ free_evars ψ1
n0: E ∉ free_evars ψ2
maximal_mu_depth_to (S depth) E ψ1
`max` maximal_mu_depth_to (S depth) E ψ2 =
S
  (maximal_mu_depth_to depth E ψ1
   `max` maximal_mu_depth_to depth E ψ2)
        exfalso.
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ1
  → maximal_mu_depth_to (S depth) E ψ1 =
    S (maximal_mu_depth_to depth E ψ1)
IHψ2: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ2
  → maximal_mu_depth_to (S depth) E ψ2 =
    S (maximal_mu_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
n: E ∉ free_evars ψ1
n0: E ∉ free_evars ψ2
False set_solver.
      }
    }
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ1
  → maximal_mu_depth_to (S depth) E ψ1 =
    S (maximal_mu_depth_to depth E ψ1)
IHψ2: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ2
  → maximal_mu_depth_to (S depth) E ψ2 =
    S (maximal_mu_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
maximal_mu_depth_to (S depth) E ψ1
`max` maximal_mu_depth_to (S depth) E ψ2 =
S
  (maximal_mu_depth_to depth E ψ1
   `max` maximal_mu_depth_to depth E ψ2)
    {
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ1
  → maximal_mu_depth_to (S depth) E ψ1 =
    S (maximal_mu_depth_to depth E ψ1)
IHψ2: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ2
  → maximal_mu_depth_to (S depth) E ψ2 =
    S (maximal_mu_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
maximal_mu_depth_to (S depth) E ψ1
`max` maximal_mu_depth_to (S depth) E ψ2 =
S
  (maximal_mu_depth_to depth E ψ1
   `max` maximal_mu_depth_to depth E ψ2)
      destruct (decide (E ∈ free_evars ψ1)),(decide (E ∈ free_evars ψ2)).
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ1
  → maximal_mu_depth_to (S depth) E ψ1 =
    S (maximal_mu_depth_to depth E ψ1)
IHψ2: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ2
  → maximal_mu_depth_to (S depth) E ψ2 =
    S (maximal_mu_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
e: E ∈ free_evars ψ1
e0: E ∈ free_evars ψ2
maximal_mu_depth_to (S depth) E ψ1
`max` maximal_mu_depth_to (S depth) E ψ2 =
S
  (maximal_mu_depth_to depth E ψ1
   `max` maximal_mu_depth_to depth E ψ2)
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ1
  → maximal_mu_depth_to (S depth) E ψ1 =
    S (maximal_mu_depth_to depth E ψ1)
IHψ2: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ2
  → maximal_mu_depth_to (S depth) E ψ2 =
    S (maximal_mu_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
e: E ∈ free_evars ψ1
n: E ∉ free_evars ψ2
maximal_mu_depth_to (S depth) E ψ1
`max` maximal_mu_depth_to (S depth) E ψ2 =
S
  (maximal_mu_depth_to depth E ψ1
   `max` maximal_mu_depth_to depth E ψ2)
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ1
  → maximal_mu_depth_to (S depth) E ψ1 =
    S (maximal_mu_depth_to depth E ψ1)
IHψ2: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ2
  → maximal_mu_depth_to (S depth) E ψ2 =
    S (maximal_mu_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
n: E ∉ free_evars ψ1
e: E ∈ free_evars ψ2
maximal_mu_depth_to (S depth) E ψ1
`max` maximal_mu_depth_to (S depth) E ψ2 =
S
  (maximal_mu_depth_to depth E ψ1
   `max` maximal_mu_depth_to depth E ψ2)
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ1
  → maximal_mu_depth_to (S depth) E ψ1 =
    S (maximal_mu_depth_to depth E ψ1)
IHψ2: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ2
  → maximal_mu_depth_to (S depth) E ψ2 =
    S (maximal_mu_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
n: E ∉ free_evars ψ1
n0: E ∉ free_evars ψ2
maximal_mu_depth_to (S depth) E ψ1
`max` maximal_mu_depth_to (S depth) E ψ2 =
S
  (maximal_mu_depth_to depth E ψ1
   `max` maximal_mu_depth_to depth E ψ2)
      {
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ1
  → maximal_mu_depth_to (S depth) E ψ1 =
    S (maximal_mu_depth_to depth E ψ1)
IHψ2: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ2
  → maximal_mu_depth_to (S depth) E ψ2 =
    S (maximal_mu_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
e: E ∈ free_evars ψ1
e0: E ∈ free_evars ψ2
maximal_mu_depth_to (S depth) E ψ1
`max` maximal_mu_depth_to (S depth) E ψ2 =
S
  (maximal_mu_depth_to depth E ψ1
   `max` maximal_mu_depth_to depth E ψ2)
        rewrite IHψ1.
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ1
  → maximal_mu_depth_to (S depth) E ψ1 =
    S (maximal_mu_depth_to depth E ψ1)
IHψ2: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ2
  → maximal_mu_depth_to (S depth) E ψ2 =
    S (maximal_mu_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
e: E ∈ free_evars ψ1
e0: E ∈ free_evars ψ2
E ∈ free_evars ψ1
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ1
  → maximal_mu_depth_to (S depth) E ψ1 =
    S (maximal_mu_depth_to depth E ψ1)
IHψ2: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ2
  → maximal_mu_depth_to (S depth) E ψ2 =
    S (maximal_mu_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
e: E ∈ free_evars ψ1
e0: E ∈ free_evars ψ2
S (maximal_mu_depth_to depth E ψ1)
`max` maximal_mu_depth_to (S depth) E ψ2 =
S
  (maximal_mu_depth_to depth E ψ1
   `max` maximal_mu_depth_to depth E ψ2) assumption.
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ1
  → maximal_mu_depth_to (S depth) E ψ1 =
    S (maximal_mu_depth_to depth E ψ1)
IHψ2: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ2
  → maximal_mu_depth_to (S depth) E ψ2 =
    S (maximal_mu_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
e: E ∈ free_evars ψ1
e0: E ∈ free_evars ψ2
S (maximal_mu_depth_to depth E ψ1)
`max` maximal_mu_depth_to (S depth) E ψ2 =
S
  (maximal_mu_depth_to depth E ψ1
   `max` maximal_mu_depth_to depth E ψ2) rewrite IHψ2.
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ1
  → maximal_mu_depth_to (S depth) E ψ1 =
    S (maximal_mu_depth_to depth E ψ1)
IHψ2: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ2
  → maximal_mu_depth_to (S depth) E ψ2 =
    S (maximal_mu_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
e: E ∈ free_evars ψ1
e0: E ∈ free_evars ψ2
E ∈ free_evars ψ2
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ1
  → maximal_mu_depth_to (S depth) E ψ1 =
    S (maximal_mu_depth_to depth E ψ1)
IHψ2: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ2
  → maximal_mu_depth_to (S depth) E ψ2 =
    S (maximal_mu_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
e: E ∈ free_evars ψ1
e0: E ∈ free_evars ψ2
S (maximal_mu_depth_to depth E ψ1)
`max` S (maximal_mu_depth_to depth E ψ2) =
S
  (maximal_mu_depth_to depth E ψ1
   `max` maximal_mu_depth_to depth E ψ2) assumption.
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ1
  → maximal_mu_depth_to (S depth) E ψ1 =
    S (maximal_mu_depth_to depth E ψ1)
IHψ2: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ2
  → maximal_mu_depth_to (S depth) E ψ2 =
    S (maximal_mu_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
e: E ∈ free_evars ψ1
e0: E ∈ free_evars ψ2
S (maximal_mu_depth_to depth E ψ1)
`max` S (maximal_mu_depth_to depth E ψ2) =
S
  (maximal_mu_depth_to depth E ψ1
   `max` maximal_mu_depth_to depth E ψ2) simpl.
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ1
  → maximal_mu_depth_to (S depth) E ψ1 =
    S (maximal_mu_depth_to depth E ψ1)
IHψ2: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ2
  → maximal_mu_depth_to (S depth) E ψ2 =
    S (maximal_mu_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
e: E ∈ free_evars ψ1
e0: E ∈ free_evars ψ2
S
  (maximal_mu_depth_to depth E ψ1
   `max` maximal_mu_depth_to depth E ψ2) =
S
  (maximal_mu_depth_to depth E ψ1
   `max` maximal_mu_depth_to depth E ψ2) reflexivity.
      }
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ1
  → maximal_mu_depth_to (S depth) E ψ1 =
    S (maximal_mu_depth_to depth E ψ1)
IHψ2: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ2
  → maximal_mu_depth_to (S depth) E ψ2 =
    S (maximal_mu_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
e: E ∈ free_evars ψ1
n: E ∉ free_evars ψ2
maximal_mu_depth_to (S depth) E ψ1
`max` maximal_mu_depth_to (S depth) E ψ2 =
S
  (maximal_mu_depth_to depth E ψ1
   `max` maximal_mu_depth_to depth E ψ2)
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ1
  → maximal_mu_depth_to (S depth) E ψ1 =
    S (maximal_mu_depth_to depth E ψ1)
IHψ2: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ2
  → maximal_mu_depth_to (S depth) E ψ2 =
    S (maximal_mu_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
n: E ∉ free_evars ψ1
e: E ∈ free_evars ψ2
maximal_mu_depth_to (S depth) E ψ1
`max` maximal_mu_depth_to (S depth) E ψ2 =
S
  (maximal_mu_depth_to depth E ψ1
   `max` maximal_mu_depth_to depth E ψ2)
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ1
  → maximal_mu_depth_to (S depth) E ψ1 =
    S (maximal_mu_depth_to depth E ψ1)
IHψ2: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ2
  → maximal_mu_depth_to (S depth) E ψ2 =
    S (maximal_mu_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
n: E ∉ free_evars ψ1
n0: E ∉ free_evars ψ2
maximal_mu_depth_to (S depth) E ψ1
`max` maximal_mu_depth_to (S depth) E ψ2 =
S
  (maximal_mu_depth_to depth E ψ1
   `max` maximal_mu_depth_to depth E ψ2)
      {
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ1
  → maximal_mu_depth_to (S depth) E ψ1 =
    S (maximal_mu_depth_to depth E ψ1)
IHψ2: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ2
  → maximal_mu_depth_to (S depth) E ψ2 =
    S (maximal_mu_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
e: E ∈ free_evars ψ1
n: E ∉ free_evars ψ2
maximal_mu_depth_to (S depth) E ψ1
`max` maximal_mu_depth_to (S depth) E ψ2 =
S
  (maximal_mu_depth_to depth E ψ1
   `max` maximal_mu_depth_to depth E ψ2)
        rewrite IHψ1.
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ1
  → maximal_mu_depth_to (S depth) E ψ1 =
    S (maximal_mu_depth_to depth E ψ1)
IHψ2: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ2
  → maximal_mu_depth_to (S depth) E ψ2 =
    S (maximal_mu_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
e: E ∈ free_evars ψ1
n: E ∉ free_evars ψ2
E ∈ free_evars ψ1
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ1
  → maximal_mu_depth_to (S depth) E ψ1 =
    S (maximal_mu_depth_to depth E ψ1)
IHψ2: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ2
  → maximal_mu_depth_to (S depth) E ψ2 =
    S (maximal_mu_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
e: E ∈ free_evars ψ1
n: E ∉ free_evars ψ2
S (maximal_mu_depth_to depth E ψ1)
`max` maximal_mu_depth_to (S depth) E ψ2 =
S
  (maximal_mu_depth_to depth E ψ1
   `max` maximal_mu_depth_to depth E ψ2) assumption.
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ1
  → maximal_mu_depth_to (S depth) E ψ1 =
    S (maximal_mu_depth_to depth E ψ1)
IHψ2: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ2
  → maximal_mu_depth_to (S depth) E ψ2 =
    S (maximal_mu_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
e: E ∈ free_evars ψ1
n: E ∉ free_evars ψ2
S (maximal_mu_depth_to depth E ψ1)
`max` maximal_mu_depth_to (S depth) E ψ2 =
S
  (maximal_mu_depth_to depth E ψ1
   `max` maximal_mu_depth_to depth E ψ2)
        apply maximal_mu_depth_to_0 with (depth := S depth) in n
          as n'.
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ1
  → maximal_mu_depth_to (S depth) E ψ1 =
    S (maximal_mu_depth_to depth E ψ1)
IHψ2: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ2
  → maximal_mu_depth_to (S depth) E ψ2 =
    S (maximal_mu_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
e: E ∈ free_evars ψ1
n: E ∉ free_evars ψ2
n': maximal_mu_depth_to (S depth) E ψ2 = 0
S (maximal_mu_depth_to depth E ψ1)
`max` maximal_mu_depth_to (S depth) E ψ2 =
S
  (maximal_mu_depth_to depth E ψ1
   `max` maximal_mu_depth_to depth E ψ2)
        apply maximal_mu_depth_to_0 with (depth := depth) in n.
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ1
  → maximal_mu_depth_to (S depth) E ψ1 =
    S (maximal_mu_depth_to depth E ψ1)
IHψ2: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ2
  → maximal_mu_depth_to (S depth) E ψ2 =
    S (maximal_mu_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
e: E ∈ free_evars ψ1
n: maximal_mu_depth_to depth E ψ2 = 0
n': maximal_mu_depth_to (S depth) E ψ2 = 0
S (maximal_mu_depth_to depth E ψ1)
`max` maximal_mu_depth_to (S depth) E ψ2 =
S
  (maximal_mu_depth_to depth E ψ1
   `max` maximal_mu_depth_to depth E ψ2)
        rewrite n.
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ1
  → maximal_mu_depth_to (S depth) E ψ1 =
    S (maximal_mu_depth_to depth E ψ1)
IHψ2: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ2
  → maximal_mu_depth_to (S depth) E ψ2 =
    S (maximal_mu_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
e: E ∈ free_evars ψ1
n: maximal_mu_depth_to depth E ψ2 = 0
n': maximal_mu_depth_to (S depth) E ψ2 = 0
S (maximal_mu_depth_to depth E ψ1)
`max` maximal_mu_depth_to (S depth) E ψ2 =
S (maximal_mu_depth_to depth E ψ1 `max` 0) lia. 
      }
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ1
  → maximal_mu_depth_to (S depth) E ψ1 =
    S (maximal_mu_depth_to depth E ψ1)
IHψ2: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ2
  → maximal_mu_depth_to (S depth) E ψ2 =
    S (maximal_mu_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
n: E ∉ free_evars ψ1
e: E ∈ free_evars ψ2
maximal_mu_depth_to (S depth) E ψ1
`max` maximal_mu_depth_to (S depth) E ψ2 =
S
  (maximal_mu_depth_to depth E ψ1
   `max` maximal_mu_depth_to depth E ψ2)
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ1
  → maximal_mu_depth_to (S depth) E ψ1 =
    S (maximal_mu_depth_to depth E ψ1)
IHψ2: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ2
  → maximal_mu_depth_to (S depth) E ψ2 =
    S (maximal_mu_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
n: E ∉ free_evars ψ1
n0: E ∉ free_evars ψ2
maximal_mu_depth_to (S depth) E ψ1
`max` maximal_mu_depth_to (S depth) E ψ2 =
S
  (maximal_mu_depth_to depth E ψ1
   `max` maximal_mu_depth_to depth E ψ2)
      {
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ1
  → maximal_mu_depth_to (S depth) E ψ1 =
    S (maximal_mu_depth_to depth E ψ1)
IHψ2: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ2
  → maximal_mu_depth_to (S depth) E ψ2 =
    S (maximal_mu_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
n: E ∉ free_evars ψ1
e: E ∈ free_evars ψ2
maximal_mu_depth_to (S depth) E ψ1
`max` maximal_mu_depth_to (S depth) E ψ2 =
S
  (maximal_mu_depth_to depth E ψ1
   `max` maximal_mu_depth_to depth E ψ2)
        rewrite IHψ2.
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ1
  → maximal_mu_depth_to (S depth) E ψ1 =
    S (maximal_mu_depth_to depth E ψ1)
IHψ2: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ2
  → maximal_mu_depth_to (S depth) E ψ2 =
    S (maximal_mu_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
n: E ∉ free_evars ψ1
e: E ∈ free_evars ψ2
E ∈ free_evars ψ2
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ1
  → maximal_mu_depth_to (S depth) E ψ1 =
    S (maximal_mu_depth_to depth E ψ1)
IHψ2: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ2
  → maximal_mu_depth_to (S depth) E ψ2 =
    S (maximal_mu_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
n: E ∉ free_evars ψ1
e: E ∈ free_evars ψ2
maximal_mu_depth_to (S depth) E ψ1
`max` S (maximal_mu_depth_to depth E ψ2) =
S
  (maximal_mu_depth_to depth E ψ1
   `max` maximal_mu_depth_to depth E ψ2) assumption.
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ1
  → maximal_mu_depth_to (S depth) E ψ1 =
    S (maximal_mu_depth_to depth E ψ1)
IHψ2: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ2
  → maximal_mu_depth_to (S depth) E ψ2 =
    S (maximal_mu_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
n: E ∉ free_evars ψ1
e: E ∈ free_evars ψ2
maximal_mu_depth_to (S depth) E ψ1
`max` S (maximal_mu_depth_to depth E ψ2) =
S
  (maximal_mu_depth_to depth E ψ1
   `max` maximal_mu_depth_to depth E ψ2)
        apply maximal_mu_depth_to_0 with (depth := S depth) in n
          as n'.
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ1
  → maximal_mu_depth_to (S depth) E ψ1 =
    S (maximal_mu_depth_to depth E ψ1)
IHψ2: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ2
  → maximal_mu_depth_to (S depth) E ψ2 =
    S (maximal_mu_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
n: E ∉ free_evars ψ1
e: E ∈ free_evars ψ2
n': maximal_mu_depth_to (S depth) E ψ1 = 0
maximal_mu_depth_to (S depth) E ψ1
`max` S (maximal_mu_depth_to depth E ψ2) =
S
  (maximal_mu_depth_to depth E ψ1
   `max` maximal_mu_depth_to depth E ψ2)
        apply maximal_mu_depth_to_0 with (depth := depth) in n.
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ1
  → maximal_mu_depth_to (S depth) E ψ1 =
    S (maximal_mu_depth_to depth E ψ1)
IHψ2: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ2
  → maximal_mu_depth_to (S depth) E ψ2 =
    S (maximal_mu_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
n: maximal_mu_depth_to depth E ψ1 = 0
e: E ∈ free_evars ψ2
n': maximal_mu_depth_to (S depth) E ψ1 = 0
maximal_mu_depth_to (S depth) E ψ1
`max` S (maximal_mu_depth_to depth E ψ2) =
S
  (maximal_mu_depth_to depth E ψ1
   `max` maximal_mu_depth_to depth E ψ2)
        rewrite n.
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ1
  → maximal_mu_depth_to (S depth) E ψ1 =
    S (maximal_mu_depth_to depth E ψ1)
IHψ2: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ2
  → maximal_mu_depth_to (S depth) E ψ2 =
    S (maximal_mu_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
n: maximal_mu_depth_to depth E ψ1 = 0
e: E ∈ free_evars ψ2
n': maximal_mu_depth_to (S depth) E ψ1 = 0
maximal_mu_depth_to (S depth) E ψ1
`max` S (maximal_mu_depth_to depth E ψ2) =
S (0 `max` maximal_mu_depth_to depth E ψ2) lia. 
      }
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ1
  → maximal_mu_depth_to (S depth) E ψ1 =
    S (maximal_mu_depth_to depth E ψ1)
IHψ2: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ2
  → maximal_mu_depth_to (S depth) E ψ2 =
    S (maximal_mu_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
n: E ∉ free_evars ψ1
n0: E ∉ free_evars ψ2
maximal_mu_depth_to (S depth) E ψ1
`max` maximal_mu_depth_to (S depth) E ψ2 =
S
  (maximal_mu_depth_to depth E ψ1
   `max` maximal_mu_depth_to depth E ψ2)
      {
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ1
  → maximal_mu_depth_to (S depth) E ψ1 =
    S (maximal_mu_depth_to depth E ψ1)
IHψ2: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ2
  → maximal_mu_depth_to (S depth) E ψ2 =
    S (maximal_mu_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
n: E ∉ free_evars ψ1
n0: E ∉ free_evars ψ2
maximal_mu_depth_to (S depth) E ψ1
`max` maximal_mu_depth_to (S depth) E ψ2 =
S
  (maximal_mu_depth_to depth E ψ1
   `max` maximal_mu_depth_to depth E ψ2)
        exfalso.
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ1
  → maximal_mu_depth_to (S depth) E ψ1 =
    S (maximal_mu_depth_to depth E ψ1)
IHψ2: ∀ (E : evar) (depth : nat),
  E ∈ free_evars ψ2
  → maximal_mu_depth_to (S depth) E ψ2 =
    S (maximal_mu_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
n: E ∉ free_evars ψ1
n0: E ∉ free_evars ψ2
False set_solver.
      }
    }
  Qed.

  Lemma svar_fresh_seq_max (SvS : SVarSet) (n1 n2 : nat) :
    (@list_to_set svar SVarSet _ _ _ (svar_fresh_seq SvS n1)) ⊆ (list_to_set (svar_fresh_seq SvS (n1 `max` n2))).
Σ: Signature
SvS: SVarSet
n1, n2: nat
list_to_set (svar_fresh_seq SvS n1)
⊆ list_to_set (svar_fresh_seq SvS (n1 `max` n2))
  Proof.
Σ: Signature
SvS: SVarSet
n1, n2: nat
list_to_set (svar_fresh_seq SvS n1)
⊆ list_to_set (svar_fresh_seq SvS (n1 `max` n2))
    move: SvS n2.
Σ: Signature
n1: nat
∀ (SvS : SVarSet) (n2 : nat),
  list_to_set (svar_fresh_seq SvS n1)
  ⊆ list_to_set (svar_fresh_seq SvS (n1 `max` n2))
    induction n1; intros SvS n2.
Σ: Signature
SvS: SVarSet
n2: nat
list_to_set (svar_fresh_seq SvS 0)
⊆ list_to_set (svar_fresh_seq SvS (0 `max` n2))
Σ: Signature
n1: nat
IHn1: ∀ (SvS : SVarSet) (n2 : nat),
  list_to_set (svar_fresh_seq SvS n1)
  ⊆ list_to_set
      (svar_fresh_seq SvS (n1 `max` n2))
SvS: SVarSet
n2: nat
list_to_set (svar_fresh_seq SvS (S n1))
⊆ list_to_set (svar_fresh_seq SvS (S n1 `max` n2))
    {
Σ: Signature
SvS: SVarSet
n2: nat
list_to_set (svar_fresh_seq SvS 0)
⊆ list_to_set (svar_fresh_seq SvS (0 `max` n2))
      simpl.
Σ: Signature
SvS: SVarSet
n2: nat
∅ ⊆ list_to_set (svar_fresh_seq SvS n2) set_solver.
    }
Σ: Signature
n1: nat
IHn1: ∀ (SvS : SVarSet) (n2 : nat),
  list_to_set (svar_fresh_seq SvS n1)
  ⊆ list_to_set
      (svar_fresh_seq SvS (n1 `max` n2))
SvS: SVarSet
n2: nat
list_to_set (svar_fresh_seq SvS (S n1))
⊆ list_to_set (svar_fresh_seq SvS (S n1 `max` n2))
    {
Σ: Signature
n1: nat
IHn1: ∀ (SvS : SVarSet) (n2 : nat),
  list_to_set (svar_fresh_seq SvS n1)
  ⊆ list_to_set
      (svar_fresh_seq SvS (n1 `max` n2))
SvS: SVarSet
n2: nat
list_to_set (svar_fresh_seq SvS (S n1))
⊆ list_to_set (svar_fresh_seq SvS (S n1 `max` n2))
      simpl.
Σ: Signature
n1: nat
IHn1: ∀ (SvS : SVarSet) (n2 : nat),
  list_to_set (svar_fresh_seq SvS n1)
  ⊆ list_to_set
      (svar_fresh_seq SvS (n1 `max` n2))
SvS: SVarSet
n2: nat
{[svar_fresh_s SvS]}
∪ list_to_set
    (svar_fresh_seq ({[svar_fresh_s SvS]} ∪ SvS) n1)
⊆ list_to_set (svar_fresh_seq SvS (S n1 `max` n2))
      destruct n2.
Σ: Signature
n1: nat
IHn1: ∀ (SvS : SVarSet) (n2 : nat),
  list_to_set (svar_fresh_seq SvS n1)
  ⊆ list_to_set
      (svar_fresh_seq SvS (n1 `max` n2))
SvS: SVarSet
{[svar_fresh_s SvS]}
∪ list_to_set
    (svar_fresh_seq ({[svar_fresh_s SvS]} ∪ SvS) n1)
⊆ list_to_set (svar_fresh_seq SvS (S n1 `max` 0))
Σ: Signature
n1: nat
IHn1: ∀ (SvS : SVarSet) (n2 : nat),
  list_to_set (svar_fresh_seq SvS n1)
  ⊆ list_to_set
      (svar_fresh_seq SvS (n1 `max` n2))
SvS: SVarSet
n2: nat
{[svar_fresh_s SvS]}
∪ list_to_set
    (svar_fresh_seq ({[svar_fresh_s SvS]} ∪ SvS) n1)
⊆ list_to_set (svar_fresh_seq SvS (S n1 `max` S n2))
      {
Σ: Signature
n1: nat
IHn1: ∀ (SvS : SVarSet) (n2 : nat),
  list_to_set (svar_fresh_seq SvS n1)
  ⊆ list_to_set
      (svar_fresh_seq SvS (n1 `max` n2))
SvS: SVarSet
{[svar_fresh_s SvS]}
∪ list_to_set
    (svar_fresh_seq ({[svar_fresh_s SvS]} ∪ SvS) n1)
⊆ list_to_set (svar_fresh_seq SvS (S n1 `max` 0))
        simpl.
Σ: Signature
n1: nat
IHn1: ∀ (SvS : SVarSet) (n2 : nat),
  list_to_set (svar_fresh_seq SvS n1)
  ⊆ list_to_set
      (svar_fresh_seq SvS (n1 `max` n2))
SvS: SVarSet
{[svar_fresh_s SvS]}
∪ list_to_set
    (svar_fresh_seq ({[svar_fresh_s SvS]} ∪ SvS) n1)
⊆ {[svar_fresh_s SvS]}
  ∪ list_to_set
      (svar_fresh_seq ({[svar_fresh_s SvS]} ∪ SvS) n1) set_solver.
      }
Σ: Signature
n1: nat
IHn1: ∀ (SvS : SVarSet) (n2 : nat),
  list_to_set (svar_fresh_seq SvS n1)
  ⊆ list_to_set
      (svar_fresh_seq SvS (n1 `max` n2))
SvS: SVarSet
n2: nat
{[svar_fresh_s SvS]}
∪ list_to_set
    (svar_fresh_seq ({[svar_fresh_s SvS]} ∪ SvS) n1)
⊆ list_to_set (svar_fresh_seq SvS (S n1 `max` S n2))
      {
Σ: Signature
n1: nat
IHn1: ∀ (SvS : SVarSet) (n2 : nat),
  list_to_set (svar_fresh_seq SvS n1)
  ⊆ list_to_set
      (svar_fresh_seq SvS (n1 `max` n2))
SvS: SVarSet
n2: nat
{[svar_fresh_s SvS]}
∪ list_to_set
    (svar_fresh_seq ({[svar_fresh_s SvS]} ∪ SvS) n1)
⊆ list_to_set (svar_fresh_seq SvS (S n1 `max` S n2))
        simpl.
Σ: Signature
n1: nat
IHn1: ∀ (SvS : SVarSet) (n2 : nat),
  list_to_set (svar_fresh_seq SvS n1)
  ⊆ list_to_set
      (svar_fresh_seq SvS (n1 `max` n2))
SvS: SVarSet
n2: nat
{[svar_fresh_s SvS]}
∪ list_to_set
    (svar_fresh_seq ({[svar_fresh_s SvS]} ∪ SvS) n1)
⊆ {[svar_fresh_s SvS]}
  ∪ list_to_set
      (svar_fresh_seq ({[svar_fresh_s SvS]} ∪ SvS)
         (n1 `max` n2))
        cut (@list_to_set svar SVarSet _ _ _ (svar_fresh_seq ({[svar_fresh_s SvS]} ∪ SvS) n1)
        ⊆ list_to_set (svar_fresh_seq ({[svar_fresh_s SvS]} ∪ SvS) (n1 `max` n2))).
Σ: Signature
n1: nat
IHn1: ∀ (SvS : SVarSet) (n2 : nat),
  list_to_set (svar_fresh_seq SvS n1)
  ⊆ list_to_set
      (svar_fresh_seq SvS (n1 `max` n2))
SvS: SVarSet
n2: nat
list_to_set
  (svar_fresh_seq ({[svar_fresh_s SvS]} ∪ SvS) n1)
⊆ list_to_set
    (svar_fresh_seq ({[svar_fresh_s SvS]} ∪ SvS)
       (n1 `max` n2))
→ {[svar_fresh_s SvS]}
  ∪ list_to_set
      (svar_fresh_seq ({[svar_fresh_s SvS]} ∪ SvS) n1)
  ⊆ {[svar_fresh_s SvS]}
    ∪ list_to_set
        (svar_fresh_seq ({[svar_fresh_s SvS]} ∪ SvS)
           (n1 `max` n2))
Σ: Signature
n1: nat
IHn1: ∀ (SvS : SVarSet) (n2 : nat),
  list_to_set (svar_fresh_seq SvS n1)
  ⊆ list_to_set
      (svar_fresh_seq SvS (n1 `max` n2))
SvS: SVarSet
n2: nat
list_to_set
  (svar_fresh_seq ({[svar_fresh_s SvS]} ∪ SvS) n1)
⊆ list_to_set
    (svar_fresh_seq ({[svar_fresh_s SvS]} ∪ SvS)
       (n1 `max` n2))
        {
Σ: Signature
n1: nat
IHn1: ∀ (SvS : SVarSet) (n2 : nat),
  list_to_set (svar_fresh_seq SvS n1)
  ⊆ list_to_set
      (svar_fresh_seq SvS (n1 `max` n2))
SvS: SVarSet
n2: nat
list_to_set
  (svar_fresh_seq ({[svar_fresh_s SvS]} ∪ SvS) n1)
⊆ list_to_set
    (svar_fresh_seq ({[svar_fresh_s SvS]} ∪ SvS)
       (n1 `max` n2))
→ {[svar_fresh_s SvS]}
  ∪ list_to_set
      (svar_fresh_seq ({[svar_fresh_s SvS]} ∪ SvS) n1)
  ⊆ {[svar_fresh_s SvS]}
    ∪ list_to_set
        (svar_fresh_seq ({[svar_fresh_s SvS]} ∪ SvS)
           (n1 `max` n2))
          set_solver.
        }
Σ: Signature
n1: nat
IHn1: ∀ (SvS : SVarSet) (n2 : nat),
  list_to_set (svar_fresh_seq SvS n1)
  ⊆ list_to_set
      (svar_fresh_seq SvS (n1 `max` n2))
SvS: SVarSet
n2: nat
list_to_set
  (svar_fresh_seq ({[svar_fresh_s SvS]} ∪ SvS) n1)
⊆ list_to_set
    (svar_fresh_seq ({[svar_fresh_s SvS]} ∪ SvS)
       (n1 `max` n2))
        specialize (IHn1 ({[svar_fresh_s SvS]} ∪ SvS) n2).
Σ: Signature
n1: nat
SvS: SVarSet
n2: nat
IHn1: list_to_set
  (svar_fresh_seq ({[svar_fresh_s SvS]} ∪ SvS)
     n1)
⊆ list_to_set
    (svar_fresh_seq
       ({[svar_fresh_s SvS]} ∪ SvS)
       (n1 `max` n2))
list_to_set
  (svar_fresh_seq ({[svar_fresh_s SvS]} ∪ SvS) n1)
⊆ list_to_set
    (svar_fresh_seq ({[svar_fresh_s SvS]} ∪ SvS)
       (n1 `max` n2))
        apply IHn1.
      }
    }
  Qed.

  (** Note: we cannot reuse NoDup, until the proof system is 
      formalised as `... -> Set`. *)
  Fixpoint no_dups {A : Set} {eqdec : EqDecision A} (l : list A) :=
    match l with
    | [] => True
    | x::xs => x ∉ xs /\ no_dups xs
    end.

  Class fresh_evars (l : list evar) (s : EVarSet) :=
  {
    evar_duplicates : no_dups l;
    all_evars_fresh : forall x, x ∈ l -> x ∉ s;
  }.

  Lemma fresh_evars_bigger {el s} s' :
    fresh_evars el s -> s' ⊆ s -> fresh_evars el s'.
Σ: Signature
el: list evar
s, s': EVarSet
fresh_evars el s → s' ⊆ s → fresh_evars el s'
  Proof.
Σ: Signature
el: list evar
s, s': EVarSet
fresh_evars el s → s' ⊆ s → fresh_evars el s' intros H H0.
Σ: Signature
el: list evar
s, s': EVarSet
H: fresh_evars el s
H0: s' ⊆ s
fresh_evars el s' constructor; destruct H.
Σ: Signature
el: list evar
s, s': EVarSet
evar_duplicates0: no_dups el
all_evars_fresh0: ∀ x : evar, x ∈ el → x ∉ s
H0: s' ⊆ s
no_dups el
Σ: Signature
el: list evar
s, s': EVarSet
evar_duplicates0: no_dups el
all_evars_fresh0: ∀ x : evar, x ∈ el → x ∉ s
H0: s' ⊆ s
∀ x : evar, x ∈ el → x ∉ s' auto.
Σ: Signature
el: list evar
s, s': EVarSet
evar_duplicates0: no_dups el
all_evars_fresh0: ∀ x : evar, x ∈ el → x ∉ s
H0: s' ⊆ s
∀ x : evar, x ∈ el → x ∉ s' intros.
Σ: Signature
el: list evar
s, s': EVarSet
evar_duplicates0: no_dups el
all_evars_fresh0: ∀ x : evar, x ∈ el → x ∉ s
H0: s' ⊆ s
x: evar
H: x ∈ el
x ∉ s' set_solver. Qed.

  Lemma less_fresh_evars {x el s} :
    fresh_evars (x::el) s -> fresh_evars el s.
Σ: Signature
x: evar
el: list evar
s: EVarSet
fresh_evars (x :: el) s → fresh_evars el s
  Proof.
Σ: Signature
x: evar
el: list evar
s: EVarSet
fresh_evars (x :: el) s → fresh_evars el s
    intros H.
Σ: Signature
x: evar
el: list evar
s: EVarSet
H: fresh_evars (x :: el) s
fresh_evars el s constructor; destruct H.
Σ: Signature
x: evar
el: list evar
s: EVarSet
evar_duplicates0: no_dups (x :: el)
all_evars_fresh0: ∀ x0 : evar, x0 ∈ x :: el → x0 ∉ s
no_dups el
Σ: Signature
x: evar
el: list evar
s: EVarSet
evar_duplicates0: no_dups (x :: el)
all_evars_fresh0: ∀ x0 : evar, x0 ∈ x :: el → x0 ∉ s
∀ x : evar, x ∈ el → x ∉ s
    simpl in *.
Σ: Signature
x: evar
el: list evar
s: EVarSet
evar_duplicates0: (x ∉ el) ∧ no_dups el
all_evars_fresh0: ∀ x0 : evar, x0 ∈ x :: el → x0 ∉ s
no_dups el
Σ: Signature
x: evar
el: list evar
s: EVarSet
evar_duplicates0: no_dups (x :: el)
all_evars_fresh0: ∀ x0 : evar, x0 ∈ x :: el → x0 ∉ s
∀ x : evar, x ∈ el → x ∉ s apply evar_duplicates0.
Σ: Signature
x: evar
el: list evar
s: EVarSet
evar_duplicates0: no_dups (x :: el)
all_evars_fresh0: ∀ x0 : evar, x0 ∈ x :: el → x0 ∉ s
∀ x : evar, x ∈ el → x ∉ s
    intros.
Σ: Signature
x: evar
el: list evar
s: EVarSet
evar_duplicates0: no_dups (x :: el)
all_evars_fresh0: ∀ x0 : evar, x0 ∈ x :: el → x0 ∉ s
x0: evar
H: x0 ∈ el
x0 ∉ s apply all_evars_fresh0.
Σ: Signature
x: evar
el: list evar
s: EVarSet
evar_duplicates0: no_dups (x :: el)
all_evars_fresh0: ∀ x0 : evar, x0 ∈ x :: el → x0 ∉ s
x0: evar
H: x0 ∈ el
x0 ∈ x :: el now constructor 2.
  Qed.

  Class fresh_svars (l : list svar) (s : SVarSet) :=
  {
    svar_duplicates : no_dups l;
    all_svars_fresh : forall X, X ∈ l -> X ∉ s;
  }.

  Lemma fresh_svars_bigger {sl s} s' :
    fresh_svars sl s -> s' ⊆ s -> fresh_svars sl s'.
Σ: Signature
sl: list svar
s, s': SVarSet
fresh_svars sl s → s' ⊆ s → fresh_svars sl s'
  Proof.
Σ: Signature
sl: list svar
s, s': SVarSet
fresh_svars sl s → s' ⊆ s → fresh_svars sl s' intros H H0.
Σ: Signature
sl: list svar
s, s': SVarSet
H: fresh_svars sl s
H0: s' ⊆ s
fresh_svars sl s' constructor; destruct H.
Σ: Signature
sl: list svar
s, s': SVarSet
svar_duplicates0: no_dups sl
all_svars_fresh0: ∀ X : svar, X ∈ sl → X ∉ s
H0: s' ⊆ s
no_dups sl
Σ: Signature
sl: list svar
s, s': SVarSet
svar_duplicates0: no_dups sl
all_svars_fresh0: ∀ X : svar, X ∈ sl → X ∉ s
H0: s' ⊆ s
∀ X : svar, X ∈ sl → X ∉ s' auto.
Σ: Signature
sl: list svar
s, s': SVarSet
svar_duplicates0: no_dups sl
all_svars_fresh0: ∀ X : svar, X ∈ sl → X ∉ s
H0: s' ⊆ s
∀ X : svar, X ∈ sl → X ∉ s' intros.
Σ: Signature
sl: list svar
s, s': SVarSet
svar_duplicates0: no_dups sl
all_svars_fresh0: ∀ X : svar, X ∈ sl → X ∉ s
H0: s' ⊆ s
X: svar
H: X ∈ sl
X ∉ s' set_solver. Qed.

  Lemma less_fresh_svars {X sl s} :
    fresh_evars (X::sl) s -> fresh_evars sl s.
Σ: Signature
X: evar
sl: list evar
s: EVarSet
fresh_evars (X :: sl) s → fresh_evars sl s
  Proof.
Σ: Signature
X: evar
sl: list evar
s: EVarSet
fresh_evars (X :: sl) s → fresh_evars sl s
    intros H.
Σ: Signature
X: evar
sl: list evar
s: EVarSet
H: fresh_evars (X :: sl) s
fresh_evars sl s constructor; destruct H.
Σ: Signature
X: evar
sl: list evar
s: EVarSet
evar_duplicates0: no_dups (X :: sl)
all_evars_fresh0: ∀ x : evar, x ∈ X :: sl → x ∉ s
no_dups sl
Σ: Signature
X: evar
sl: list evar
s: EVarSet
evar_duplicates0: no_dups (X :: sl)
all_evars_fresh0: ∀ x : evar, x ∈ X :: sl → x ∉ s
∀ x : evar, x ∈ sl → x ∉ s
    simpl in *.
Σ: Signature
X: evar
sl: list evar
s: EVarSet
evar_duplicates0: (X ∉ sl) ∧ no_dups sl
all_evars_fresh0: ∀ x : evar, x ∈ X :: sl → x ∉ s
no_dups sl
Σ: Signature
X: evar
sl: list evar
s: EVarSet
evar_duplicates0: no_dups (X :: sl)
all_evars_fresh0: ∀ x : evar, x ∈ X :: sl → x ∉ s
∀ x : evar, x ∈ sl → x ∉ s apply evar_duplicates0.
Σ: Signature
X: evar
sl: list evar
s: EVarSet
evar_duplicates0: no_dups (X :: sl)
all_evars_fresh0: ∀ x : evar, x ∈ X :: sl → x ∉ s
∀ x : evar, x ∈ sl → x ∉ s
    intros.
Σ: Signature
X: evar
sl: list evar
s: EVarSet
evar_duplicates0: no_dups (X :: sl)
all_evars_fresh0: ∀ x : evar, x ∈ X :: sl → x ∉ s
x: evar
H: x ∈ sl
x ∉ s apply all_evars_fresh0.
Σ: Signature
X: evar
sl: list evar
s: EVarSet
evar_duplicates0: no_dups (X :: sl)
all_evars_fresh0: ∀ x : evar, x ∈ X :: sl → x ∉ s
x: evar
H: x ∈ sl
x ∈ X :: sl now constructor 2.
  Qed.

  Lemma congruence_ex Γ E ψ x p q gpi kt evs svs
    (HxneqE : x ≠ E)
    (wfψ : well_formed (ex , ψ))
    (wfp : well_formed p)
    (wfq : well_formed q)
    (Heqx : x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q)
    (Heqx2 : x ∈ evs)
    (pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := kt) gpi)
    (IH: Γ ⊢i ψ^{evar: 0 ↦ x}^[[evar: E ↦ p]] <---> ψ^{evar: 0 ↦ x}^[[evar: E ↦ q]]
       using  gpi) :
    (Γ ⊢i (ex , ψ^[[evar: E ↦ p]]) <---> (ex , ψ^[[evar: E ↦ q]]) using  gpi).
Σ: Signature
Γ: Theory
E: evar
ψ: Pattern
x: evar
p, q: Pattern
gpi: ProofInfo
kt: bool
evs: coEVarSet
svs: coSVarSet
HxneqE: x ≠ E
wfψ: well_formed (ex , ψ)
wfp: well_formed p
wfq: well_formed q
Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Heqx2: x ∈ evs
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := kt) gpi
IH: Γ
⊢i ψ^{evar:0↦x}^[[evar:E↦p]] <--->
   ψ^{evar:0↦x}^[[evar:E↦q]] using gpi
Γ ⊢i (ex , ψ^[[evar:E↦p]]) <---> (ex , ψ^[[evar:E↦q]])
using gpi
  Proof.
Σ: Signature
Γ: Theory
E: evar
ψ: Pattern
x: evar
p, q: Pattern
gpi: ProofInfo
kt: bool
evs: coEVarSet
svs: coSVarSet
HxneqE: x ≠ E
wfψ: well_formed (ex , ψ)
wfp: well_formed p
wfq: well_formed q
Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Heqx2: x ∈ evs
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := kt) gpi
IH: Γ
⊢i ψ^{evar:0↦x}^[[evar:E↦p]] <--->
   ψ^{evar:0↦x}^[[evar:E↦q]] using gpi
Γ ⊢i (ex , ψ^[[evar:E↦p]]) <---> (ex , ψ^[[evar:E↦q]])
using gpi
    rewrite -evar_open_free_evar_subst_swap in IH; auto.
Σ: Signature
Γ: Theory
E: evar
ψ: Pattern
x: evar
p, q: Pattern
gpi: ProofInfo
kt: bool
evs: coEVarSet
svs: coSVarSet
HxneqE: x ≠ E
wfψ: well_formed (ex , ψ)
wfp: well_formed p
wfq: well_formed q
Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Heqx2: x ∈ evs
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := kt) gpi
IH: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <--->
   ψ^{evar:0↦x}^[[evar:E↦q]] using gpi
Γ ⊢i (ex , ψ^[[evar:E↦p]]) <---> (ex , ψ^[[evar:E↦q]])
using gpi
    rewrite -evar_open_free_evar_subst_swap in IH; auto.
Σ: Signature
Γ: Theory
E: evar
ψ: Pattern
x: evar
p, q: Pattern
gpi: ProofInfo
kt: bool
evs: coEVarSet
svs: coSVarSet
HxneqE: x ≠ E
wfψ: well_formed (ex , ψ)
wfp: well_formed p
wfq: well_formed q
Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Heqx2: x ∈ evs
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := kt) gpi
IH: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <--->
   ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
Γ ⊢i (ex , ψ^[[evar:E↦p]]) <---> (ex , ψ^[[evar:E↦q]])
using gpi
    unshelve (epose proof (IH1 := pf_iff_proj1 Γ _ _ _ _ _ IH)).
Σ: Signature
Γ: Theory
E: evar
ψ: Pattern
x: evar
p, q: Pattern
gpi: ProofInfo
kt: bool
evs: coEVarSet
svs: coSVarSet
HxneqE: x ≠ E
wfψ: well_formed (ex , ψ)
wfp: well_formed p
wfq: well_formed q
Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Heqx2: x ∈ evs
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := kt) gpi
IH: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <--->
   ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
well_formed ψ^[[evar:E↦p]]^{evar:0↦x}
Σ: Signature
Γ: Theory
E: evar
ψ: Pattern
x: evar
p, q: Pattern
gpi: ProofInfo
kt: bool
evs: coEVarSet
svs: coSVarSet
HxneqE: x ≠ E
wfψ: well_formed (ex , ψ)
wfp: well_formed p
wfq: well_formed q
Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Heqx2: x ∈ evs
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := kt) gpi
IH: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <--->
   ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
well_formed ψ^[[evar:E↦q]]^{evar:0↦x}
Σ: Signature
Γ: Theory
E: evar
ψ: Pattern
x: evar
p, q: Pattern
gpi: ProofInfo
kt: bool
evs: coEVarSet
svs: coSVarSet
HxneqE: x ≠ E
wfψ: well_formed (ex , ψ)
wfp: well_formed p
wfq: well_formed q
Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Heqx2: x ∈ evs
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := kt) gpi
IH: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <--->
   ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH1: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} --->
   ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
Γ ⊢i (ex , ψ^[[evar:E↦p]]) <---> (ex , ψ^[[evar:E↦q]])
using gpi
    {
Σ: Signature
Γ: Theory
E: evar
ψ: Pattern
x: evar
p, q: Pattern
gpi: ProofInfo
kt: bool
evs: coEVarSet
svs: coSVarSet
HxneqE: x ≠ E
wfψ: well_formed (ex , ψ)
wfp: well_formed p
wfq: well_formed q
Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Heqx2: x ∈ evs
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := kt) gpi
IH: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <--->
   ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
well_formed ψ^[[evar:E↦p]]^{evar:0↦x} abstract (wf_auto2). }
Σ: Signature
Γ: Theory
E: evar
ψ: Pattern
x: evar
p, q: Pattern
gpi: ProofInfo
kt: bool
evs: coEVarSet
svs: coSVarSet
HxneqE: x ≠ E
wfψ: well_formed (ex , ψ)
wfp: well_formed p
wfq: well_formed q
Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Heqx2: x ∈ evs
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := kt) gpi
IH: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <--->
   ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
well_formed ψ^[[evar:E↦q]]^{evar:0↦x}
Σ: Signature
Γ: Theory
E: evar
ψ: Pattern
x: evar
p, q: Pattern
gpi: ProofInfo
kt: bool
evs: coEVarSet
svs: coSVarSet
HxneqE: x ≠ E
wfψ: well_formed (ex , ψ)
wfp: well_formed p
wfq: well_formed q
Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Heqx2: x ∈ evs
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := kt) gpi
IH: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <--->
   ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH1: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} --->
   ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
Γ ⊢i (ex , ψ^[[evar:E↦p]]) <---> (ex , ψ^[[evar:E↦q]])
using gpi
    {
Σ: Signature
Γ: Theory
E: evar
ψ: Pattern
x: evar
p, q: Pattern
gpi: ProofInfo
kt: bool
evs: coEVarSet
svs: coSVarSet
HxneqE: x ≠ E
wfψ: well_formed (ex , ψ)
wfp: well_formed p
wfq: well_formed q
Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Heqx2: x ∈ evs
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := kt) gpi
IH: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <--->
   ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
well_formed ψ^[[evar:E↦q]]^{evar:0↦x} abstract (wf_auto2). }
Σ: Signature
Γ: Theory
E: evar
ψ: Pattern
x: evar
p, q: Pattern
gpi: ProofInfo
kt: bool
evs: coEVarSet
svs: coSVarSet
HxneqE: x ≠ E
wfψ: well_formed (ex , ψ)
wfp: well_formed p
wfq: well_formed q
Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Heqx2: x ∈ evs
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := kt) gpi
IH: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <--->
   ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH1: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} --->
   ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
Γ ⊢i (ex , ψ^[[evar:E↦p]]) <---> (ex , ψ^[[evar:E↦q]])
using gpi
    unshelve (epose proof (IH2 := pf_iff_proj2 Γ _ _ _ _ _ IH)).
Σ: Signature
Γ: Theory
E: evar
ψ: Pattern
x: evar
p, q: Pattern
gpi: ProofInfo
kt: bool
evs: coEVarSet
svs: coSVarSet
HxneqE: x ≠ E
wfψ: well_formed (ex , ψ)
wfp: well_formed p
wfq: well_formed q
Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Heqx2: x ∈ evs
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := kt) gpi
IH: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <--->
   ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH1: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} --->
   ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
well_formed ψ^[[evar:E↦p]]^{evar:0↦x}
Σ: Signature
Γ: Theory
E: evar
ψ: Pattern
x: evar
p, q: Pattern
gpi: ProofInfo
kt: bool
evs: coEVarSet
svs: coSVarSet
HxneqE: x ≠ E
wfψ: well_formed (ex , ψ)
wfp: well_formed p
wfq: well_formed q
Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Heqx2: x ∈ evs
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := kt) gpi
IH: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <--->
   ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH1: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} --->
   ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
well_formed ψ^[[evar:E↦q]]^{evar:0↦x}
Σ: Signature
Γ: Theory
E: evar
ψ: Pattern
x: evar
p, q: Pattern
gpi: ProofInfo
kt: bool
evs: coEVarSet
svs: coSVarSet
HxneqE: x ≠ E
wfψ: well_formed (ex , ψ)
wfp: well_formed p
wfq: well_formed q
Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Heqx2: x ∈ evs
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := kt) gpi
IH: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <--->
   ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH1: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} --->
   ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH2: Γ
⊢i ψ^[[evar:E↦q]]^{evar:0↦x} --->
   ψ^[[evar:E↦p]]^{evar:0↦x} using gpi
Γ ⊢i (ex , ψ^[[evar:E↦p]]) <---> (ex , ψ^[[evar:E↦q]])
using gpi
    {
Σ: Signature
Γ: Theory
E: evar
ψ: Pattern
x: evar
p, q: Pattern
gpi: ProofInfo
kt: bool
evs: coEVarSet
svs: coSVarSet
HxneqE: x ≠ E
wfψ: well_formed (ex , ψ)
wfp: well_formed p
wfq: well_formed q
Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Heqx2: x ∈ evs
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := kt) gpi
IH: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <--->
   ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH1: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} --->
   ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
well_formed ψ^[[evar:E↦p]]^{evar:0↦x} abstract (wf_auto2). }
Σ: Signature
Γ: Theory
E: evar
ψ: Pattern
x: evar
p, q: Pattern
gpi: ProofInfo
kt: bool
evs: coEVarSet
svs: coSVarSet
HxneqE: x ≠ E
wfψ: well_formed (ex , ψ)
wfp: well_formed p
wfq: well_formed q
Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Heqx2: x ∈ evs
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := kt) gpi
IH: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <--->
   ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH1: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} --->
   ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
well_formed ψ^[[evar:E↦q]]^{evar:0↦x}
Σ: Signature
Γ: Theory
E: evar
ψ: Pattern
x: evar
p, q: Pattern
gpi: ProofInfo
kt: bool
evs: coEVarSet
svs: coSVarSet
HxneqE: x ≠ E
wfψ: well_formed (ex , ψ)
wfp: well_formed p
wfq: well_formed q
Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Heqx2: x ∈ evs
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := kt) gpi
IH: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <--->
   ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH1: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} --->
   ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH2: Γ
⊢i ψ^[[evar:E↦q]]^{evar:0↦x} --->
   ψ^[[evar:E↦p]]^{evar:0↦x} using gpi
Γ ⊢i (ex , ψ^[[evar:E↦p]]) <---> (ex , ψ^[[evar:E↦q]])
using gpi
    {
Σ: Signature
Γ: Theory
E: evar
ψ: Pattern
x: evar
p, q: Pattern
gpi: ProofInfo
kt: bool
evs: coEVarSet
svs: coSVarSet
HxneqE: x ≠ E
wfψ: well_formed (ex , ψ)
wfp: well_formed p
wfq: well_formed q
Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Heqx2: x ∈ evs
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := kt) gpi
IH: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <--->
   ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH1: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} --->
   ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
well_formed ψ^[[evar:E↦q]]^{evar:0↦x} abstract (wf_auto2). }
Σ: Signature
Γ: Theory
E: evar
ψ: Pattern
x: evar
p, q: Pattern
gpi: ProofInfo
kt: bool
evs: coEVarSet
svs: coSVarSet
HxneqE: x ≠ E
wfψ: well_formed (ex , ψ)
wfp: well_formed p
wfq: well_formed q
Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Heqx2: x ∈ evs
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := kt) gpi
IH: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <--->
   ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH1: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} --->
   ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH2: Γ
⊢i ψ^[[evar:E↦q]]^{evar:0↦x} --->
   ψ^[[evar:E↦p]]^{evar:0↦x} using gpi
Γ ⊢i (ex , ψ^[[evar:E↦p]]) <---> (ex , ψ^[[evar:E↦q]])
using gpi

    (* TODO: remove the well-formedness constraints on this lemma*)
    apply pf_iff_split.
Σ: Signature
Γ: Theory
E: evar
ψ: Pattern
x: evar
p, q: Pattern
gpi: ProofInfo
kt: bool
evs: coEVarSet
svs: coSVarSet
HxneqE: x ≠ E
wfψ: well_formed (ex , ψ)
wfp: well_formed p
wfq: well_formed q
Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Heqx2: x ∈ evs
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := kt) gpi
IH: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <--->
   ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH1: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} --->
   ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH2: Γ
⊢i ψ^[[evar:E↦q]]^{evar:0↦x} --->
   ψ^[[evar:E↦p]]^{evar:0↦x} using gpi
well_formed (ex , ψ^[[evar:E↦p]])
Σ: Signature
Γ: Theory
E: evar
ψ: Pattern
x: evar
p, q: Pattern
gpi: ProofInfo
kt: bool
evs: coEVarSet
svs: coSVarSet
HxneqE: x ≠ E
wfψ: well_formed (ex , ψ)
wfp: well_formed p
wfq: well_formed q
Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Heqx2: x ∈ evs
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := kt) gpi
IH: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <--->
   ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH1: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} --->
   ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH2: Γ
⊢i ψ^[[evar:E↦q]]^{evar:0↦x} --->
   ψ^[[evar:E↦p]]^{evar:0↦x} using gpi
well_formed (ex , ψ^[[evar:E↦q]])
Σ: Signature
Γ: Theory
E: evar
ψ: Pattern
x: evar
p, q: Pattern
gpi: ProofInfo
kt: bool
evs: coEVarSet
svs: coSVarSet
HxneqE: x ≠ E
wfψ: well_formed (ex , ψ)
wfp: well_formed p
wfq: well_formed q
Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Heqx2: x ∈ evs
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := kt) gpi
IH: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <--->
   ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH1: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} --->
   ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH2: Γ
⊢i ψ^[[evar:E↦q]]^{evar:0↦x} --->
   ψ^[[evar:E↦p]]^{evar:0↦x} using gpi
Γ ⊢i (ex , ψ^[[evar:E↦p]]) ---> (ex , ψ^[[evar:E↦q]])
using gpi
Σ: Signature
Γ: Theory
E: evar
ψ: Pattern
x: evar
p, q: Pattern
gpi: ProofInfo
kt: bool
evs: coEVarSet
svs: coSVarSet
HxneqE: x ≠ E
wfψ: well_formed (ex , ψ)
wfp: well_formed p
wfq: well_formed q
Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Heqx2: x ∈ evs
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := kt) gpi
IH: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <--->
   ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH1: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} --->
   ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH2: Γ
⊢i ψ^[[evar:E↦q]]^{evar:0↦x} --->
   ψ^[[evar:E↦p]]^{evar:0↦x} using gpi
Γ ⊢i (ex , ψ^[[evar:E↦q]]) ---> (ex , ψ^[[evar:E↦p]])
using gpi
    {
Σ: Signature
Γ: Theory
E: evar
ψ: Pattern
x: evar
p, q: Pattern
gpi: ProofInfo
kt: bool
evs: coEVarSet
svs: coSVarSet
HxneqE: x ≠ E
wfψ: well_formed (ex , ψ)
wfp: well_formed p
wfq: well_formed q
Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Heqx2: x ∈ evs
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := kt) gpi
IH: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <--->
   ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH1: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} --->
   ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH2: Γ
⊢i ψ^[[evar:E↦q]]^{evar:0↦x} --->
   ψ^[[evar:E↦p]]^{evar:0↦x} using gpi
well_formed (ex , ψ^[[evar:E↦p]]) abstract (wf_auto2). }
Σ: Signature
Γ: Theory
E: evar
ψ: Pattern
x: evar
p, q: Pattern
gpi: ProofInfo
kt: bool
evs: coEVarSet
svs: coSVarSet
HxneqE: x ≠ E
wfψ: well_formed (ex , ψ)
wfp: well_formed p
wfq: well_formed q
Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Heqx2: x ∈ evs
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := kt) gpi
IH: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <--->
   ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH1: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} --->
   ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH2: Γ
⊢i ψ^[[evar:E↦q]]^{evar:0↦x} --->
   ψ^[[evar:E↦p]]^{evar:0↦x} using gpi
well_formed (ex , ψ^[[evar:E↦q]])
Σ: Signature
Γ: Theory
E: evar
ψ: Pattern
x: evar
p, q: Pattern
gpi: ProofInfo
kt: bool
evs: coEVarSet
svs: coSVarSet
HxneqE: x ≠ E
wfψ: well_formed (ex , ψ)
wfp: well_formed p
wfq: well_formed q
Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Heqx2: x ∈ evs
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := kt) gpi
IH: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <--->
   ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH1: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} --->
   ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH2: Γ
⊢i ψ^[[evar:E↦q]]^{evar:0↦x} --->
   ψ^[[evar:E↦p]]^{evar:0↦x} using gpi
Γ ⊢i (ex , ψ^[[evar:E↦p]]) ---> (ex , ψ^[[evar:E↦q]])
using gpi
Σ: Signature
Γ: Theory
E: evar
ψ: Pattern
x: evar
p, q: Pattern
gpi: ProofInfo
kt: bool
evs: coEVarSet
svs: coSVarSet
HxneqE: x ≠ E
wfψ: well_formed (ex , ψ)
wfp: well_formed p
wfq: well_formed q
Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Heqx2: x ∈ evs
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := kt) gpi
IH: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <--->
   ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH1: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} --->
   ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH2: Γ
⊢i ψ^[[evar:E↦q]]^{evar:0↦x} --->
   ψ^[[evar:E↦p]]^{evar:0↦x} using gpi
Γ ⊢i (ex , ψ^[[evar:E↦q]]) ---> (ex , ψ^[[evar:E↦p]])
using gpi
    {
Σ: Signature
Γ: Theory
E: evar
ψ: Pattern
x: evar
p, q: Pattern
gpi: ProofInfo
kt: bool
evs: coEVarSet
svs: coSVarSet
HxneqE: x ≠ E
wfψ: well_formed (ex , ψ)
wfp: well_formed p
wfq: well_formed q
Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Heqx2: x ∈ evs
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := kt) gpi
IH: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <--->
   ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH1: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} --->
   ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH2: Γ
⊢i ψ^[[evar:E↦q]]^{evar:0↦x} --->
   ψ^[[evar:E↦p]]^{evar:0↦x} using gpi
well_formed (ex , ψ^[[evar:E↦q]]) abstract (wf_auto2). }
Σ: Signature
Γ: Theory
E: evar
ψ: Pattern
x: evar
p, q: Pattern
gpi: ProofInfo
kt: bool
evs: coEVarSet
svs: coSVarSet
HxneqE: x ≠ E
wfψ: well_formed (ex , ψ)
wfp: well_formed p
wfq: well_formed q
Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Heqx2: x ∈ evs
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := kt) gpi
IH: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <--->
   ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH1: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} --->
   ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH2: Γ
⊢i ψ^[[evar:E↦q]]^{evar:0↦x} --->
   ψ^[[evar:E↦p]]^{evar:0↦x} using gpi
Γ ⊢i (ex , ψ^[[evar:E↦p]]) ---> (ex , ψ^[[evar:E↦q]])
using gpi
Σ: Signature
Γ: Theory
E: evar
ψ: Pattern
x: evar
p, q: Pattern
gpi: ProofInfo
kt: bool
evs: coEVarSet
svs: coSVarSet
HxneqE: x ≠ E
wfψ: well_formed (ex , ψ)
wfp: well_formed p
wfq: well_formed q
Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Heqx2: x ∈ evs
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := kt) gpi
IH: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <--->
   ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH1: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} --->
   ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH2: Γ
⊢i ψ^[[evar:E↦q]]^{evar:0↦x} --->
   ψ^[[evar:E↦p]]^{evar:0↦x} using gpi
Γ ⊢i (ex , ψ^[[evar:E↦q]]) ---> (ex , ψ^[[evar:E↦p]])
using gpi
    {
Σ: Signature
Γ: Theory
E: evar
ψ: Pattern
x: evar
p, q: Pattern
gpi: ProofInfo
kt: bool
evs: coEVarSet
svs: coSVarSet
HxneqE: x ≠ E
wfψ: well_formed (ex , ψ)
wfp: well_formed p
wfq: well_formed q
Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Heqx2: x ∈ evs
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := kt) gpi
IH: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <--->
   ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH1: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} --->
   ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH2: Γ
⊢i ψ^[[evar:E↦q]]^{evar:0↦x} --->
   ψ^[[evar:E↦p]]^{evar:0↦x} using gpi
Γ ⊢i (ex , ψ^[[evar:E↦p]]) ---> (ex , ψ^[[evar:E↦q]])
using gpi
      eapply strip_exists_quantify_l.
Σ: Signature
Γ: Theory
E: evar
ψ: Pattern
x: evar
p, q: Pattern
gpi: ProofInfo
kt: bool
evs: coEVarSet
svs: coSVarSet
HxneqE: x ≠ E
wfψ: well_formed (ex , ψ)
wfp: well_formed p
wfq: well_formed q
Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Heqx2: x ∈ evs
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := kt) gpi
IH: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <--->
   ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH1: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} --->
   ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH2: Γ
⊢i ψ^[[evar:E↦q]]^{evar:0↦x} --->
   ψ^[[evar:E↦p]]^{evar:0↦x} using gpi
?x ∉ free_evars ψ^[[evar:E↦p]]
Σ: Signature
Γ: Theory
E: evar
ψ: Pattern
x: evar
p, q: Pattern
gpi: ProofInfo
kt: bool
evs: coEVarSet
svs: coSVarSet
HxneqE: x ≠ E
wfψ: well_formed (ex , ψ)
wfp: well_formed p
wfq: well_formed q
Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Heqx2: x ∈ evs
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := kt) gpi
IH: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <--->
   ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH1: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} --->
   ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH2: Γ
⊢i ψ^[[evar:E↦q]]^{evar:0↦x} --->
   ψ^[[evar:E↦p]]^{evar:0↦x} using gpi
well_formed_closed_ex_aux ψ^[[evar:E↦p]] 1
Σ: Signature
Γ: Theory
E: evar
ψ: Pattern
x: evar
p, q: Pattern
gpi: ProofInfo
kt: bool
evs: coEVarSet
svs: coSVarSet
HxneqE: x ≠ E
wfψ: well_formed (ex , ψ)
wfp: well_formed p
wfq: well_formed q
Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Heqx2: x ∈ evs
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := kt) gpi
IH: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <--->
   ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH1: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} --->
   ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH2: Γ
⊢i ψ^[[evar:E↦q]]^{evar:0↦x} --->
   ψ^[[evar:E↦p]]^{evar:0↦x} using gpi
Γ
⊢i exists_quantify ?x ψ^[[evar:E↦p]]^{evar:0↦?x} --->
   (ex , ψ^[[evar:E↦q]]) using gpi
      3: {
Σ: Signature
Γ: Theory
E: evar
ψ: Pattern
x: evar
p, q: Pattern
gpi: ProofInfo
kt: bool
evs: coEVarSet
svs: coSVarSet
HxneqE: x ≠ E
wfψ: well_formed (ex , ψ)
wfp: well_formed p
wfq: well_formed q
Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Heqx2: x ∈ evs
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := kt) gpi
IH: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <--->
   ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH1: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} --->
   ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH2: Γ
⊢i ψ^[[evar:E↦q]]^{evar:0↦x} --->
   ψ^[[evar:E↦p]]^{evar:0↦x} using gpi
Γ
⊢i exists_quantify ?x ψ^[[evar:E↦p]]^{evar:0↦?x} --->
   (ex , ψ^[[evar:E↦q]]) using gpi
        apply Ex_gen.
Σ: Signature
Γ: Theory
E: evar
ψ: Pattern
x: evar
p, q: Pattern
gpi: ProofInfo
kt: bool
evs: coEVarSet
svs: coSVarSet
HxneqE: x ≠ E
wfψ: well_formed (ex , ψ)
wfp: well_formed p
wfq: well_formed q
Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Heqx2: x ∈ evs
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := kt) gpi
IH: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <--->
   ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH1: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} --->
   ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH2: Γ
⊢i ψ^[[evar:E↦q]]^{evar:0↦x} --->
   ψ^[[evar:E↦p]]^{evar:0↦x} using gpi
ProofInfoLe
  (ExGen := {[?x]}, SVSubst := ∅, KT := false) gpi
Σ: Signature
Γ: Theory
E: evar
ψ: Pattern
x: evar
p, q: Pattern
gpi: ProofInfo
kt: bool
evs: coEVarSet
svs: coSVarSet
HxneqE: x ≠ E
wfψ: well_formed (ex , ψ)
wfp: well_formed p
wfq: well_formed q
Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Heqx2: x ∈ evs
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := kt) gpi
IH: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <--->
   ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH1: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} --->
   ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH2: Γ
⊢i ψ^[[evar:E↦q]]^{evar:0↦x} --->
   ψ^[[evar:E↦p]]^{evar:0↦x} using gpi
?x ∉ free_evars (ex , ψ^[[evar:E↦q]])
Σ: Signature
Γ: Theory
E: evar
ψ: Pattern
x: evar
p, q: Pattern
gpi: ProofInfo
kt: bool
evs: coEVarSet
svs: coSVarSet
HxneqE: x ≠ E
wfψ: well_formed (ex , ψ)
wfp: well_formed p
wfq: well_formed q
Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Heqx2: x ∈ evs
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := kt) gpi
IH: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <--->
   ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH1: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} --->
   ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH2: Γ
⊢i ψ^[[evar:E↦q]]^{evar:0↦x} --->
   ψ^[[evar:E↦p]]^{evar:0↦x} using gpi
Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦
   ?x} ---> (ex , ψ^[[evar:E↦q]]) using gpi
        3: {
Σ: Signature
Γ: Theory
E: evar
ψ: Pattern
x: evar
p, q: Pattern
gpi: ProofInfo
kt: bool
evs: coEVarSet
svs: coSVarSet
HxneqE: x ≠ E
wfψ: well_formed (ex , ψ)
wfp: well_formed p
wfq: well_formed q
Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Heqx2: x ∈ evs
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := kt) gpi
IH: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <--->
   ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH1: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} --->
   ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH2: Γ
⊢i ψ^[[evar:E↦q]]^{evar:0↦x} --->
   ψ^[[evar:E↦p]]^{evar:0↦x} using gpi
Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦?x} --->
   (ex , ψ^[[evar:E↦q]]) using gpi
          eapply syllogism_meta.
Σ: Signature
Γ: Theory
E: evar
ψ: Pattern
x: evar
p, q: Pattern
gpi: ProofInfo
kt: bool
evs: coEVarSet
svs: coSVarSet
HxneqE: x ≠ E
wfψ: well_formed (ex , ψ)
wfp: well_formed p
wfq: well_formed q
Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Heqx2: x ∈ evs
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := kt) gpi
IH: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <--->
   ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH1: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} --->
   ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH2: Γ
⊢i ψ^[[evar:E↦q]]^{evar:0↦x} --->
   ψ^[[evar:E↦p]]^{evar:0↦x} using gpi
well_formed ψ^[[evar:E↦p]]^{evar:0↦?x}
Σ: Signature
Γ: Theory
E: evar
ψ: Pattern
x: evar
p, q: Pattern
gpi: ProofInfo
kt: bool
evs: coEVarSet
svs: coSVarSet
HxneqE: x ≠ E
wfψ: well_formed (ex , ψ)
wfp: well_formed p
wfq: well_formed q
Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Heqx2: x ∈ evs
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := kt) gpi
IH: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <--->
   ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH1: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} --->
   ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH2: Γ
⊢i ψ^[[evar:E↦q]]^{evar:0↦x} --->
   ψ^[[evar:E↦p]]^{evar:0↦x} using gpi
well_formed ?B
Σ: Signature
Γ: Theory
E: evar
ψ: Pattern
x: evar
p, q: Pattern
gpi: ProofInfo
kt: bool
evs: coEVarSet
svs: coSVarSet
HxneqE: x ≠ E
wfψ: well_formed (ex , ψ)
wfp: well_formed p
wfq: well_formed q
Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Heqx2: x ∈ evs
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := kt) gpi
IH: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <--->
   ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH1: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} --->
   ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH2: Γ
⊢i ψ^[[evar:E↦q]]^{evar:0↦x} --->
   ψ^[[evar:E↦p]]^{evar:0↦x} using gpi
well_formed (ex , ψ^[[evar:E↦q]])
Σ: Signature
Γ: Theory
E: evar
ψ: Pattern
x: evar
p, q: Pattern
gpi: ProofInfo
kt: bool
evs: coEVarSet
svs: coSVarSet
HxneqE: x ≠ E
wfψ: well_formed (ex , ψ)
wfp: well_formed p
wfq: well_formed q
Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Heqx2: x ∈ evs
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := kt) gpi
IH: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <--->
   ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH1: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} --->
   ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH2: Γ
⊢i ψ^[[evar:E↦q]]^{evar:0↦x} --->
   ψ^[[evar:E↦p]]^{evar:0↦x} using gpi
Γ ⊢i ψ^[[evar:E↦p]]^{evar:0↦?x} ---> ?B using gpi
Σ: Signature
Γ: Theory
E: evar
ψ: Pattern
x: evar
p, q: Pattern
gpi: ProofInfo
kt: bool
evs: coEVarSet
svs: coSVarSet
HxneqE: x ≠ E
wfψ: well_formed (ex , ψ)
wfp: well_formed p
wfq: well_formed q
Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Heqx2: x ∈ evs
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := kt) gpi
IH: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <--->
   ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH1: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} --->
   ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH2: Γ
⊢i ψ^[[evar:E↦q]]^{evar:0↦x} --->
   ψ^[[evar:E↦p]]^{evar:0↦x} using gpi
Γ ⊢i ?B ---> (ex , ψ^[[evar:E↦q]]) using gpi
          5: {
Σ: Signature
Γ: Theory
E: evar
ψ: Pattern
x: evar
p, q: Pattern
gpi: ProofInfo
kt: bool
evs: coEVarSet
svs: coSVarSet
HxneqE: x ≠ E
wfψ: well_formed (ex , ψ)
wfp: well_formed p
wfq: well_formed q
Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Heqx2: x ∈ evs
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := kt) gpi
IH: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <--->
   ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH1: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} --->
   ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH2: Γ
⊢i ψ^[[evar:E↦q]]^{evar:0↦x} --->
   ψ^[[evar:E↦p]]^{evar:0↦x} using gpi
Γ ⊢i ?B ---> (ex , ψ^[[evar:E↦q]]) using gpi
            useBasicReasoning.
Σ: Signature
Γ: Theory
E: evar
ψ: Pattern
x: evar
p, q: Pattern
gpi: ProofInfo
kt: bool
evs: coEVarSet
svs: coSVarSet
HxneqE: x ≠ E
wfψ: well_formed (ex , ψ)
wfp: well_formed p
wfq: well_formed q
Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Heqx2: x ∈ evs
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := kt) gpi
IH: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <--->
   ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH1: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} --->
   ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH2: Γ
⊢i ψ^[[evar:E↦q]]^{evar:0↦x} --->
   ψ^[[evar:E↦p]]^{evar:0↦x} using gpi
Γ ⊢i ?B ---> (ex , ψ^[[evar:E↦q]])
using BasicReasoning
            apply Ex_quan.
Σ: Signature
Γ: Theory
E: evar
ψ: Pattern
x: evar
p, q: Pattern
gpi: ProofInfo
kt: bool
evs: coEVarSet
svs: coSVarSet
HxneqE: x ≠ E
wfψ: well_formed (ex , ψ)
wfp: well_formed p
wfq: well_formed q
Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Heqx2: x ∈ evs
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := kt) gpi
IH: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <--->
   ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH1: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} --->
   ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH2: Γ
⊢i ψ^[[evar:E↦q]]^{evar:0↦x} --->
   ψ^[[evar:E↦p]]^{evar:0↦x} using gpi
well_formed (ex , ψ^[[evar:E↦q]])
            abstract (wf_auto2).
          }
Σ: Signature
Γ: Theory
E: evar
ψ: Pattern
x: evar
p, q: Pattern
gpi: ProofInfo
kt: bool
evs: coEVarSet
svs: coSVarSet
HxneqE: x ≠ E
wfψ: well_formed (ex , ψ)
wfp: well_formed p
wfq: well_formed q
Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Heqx2: x ∈ evs
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := kt) gpi
IH: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <--->
   ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH1: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} --->
   ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH2: Γ
⊢i ψ^[[evar:E↦q]]^{evar:0↦x} --->
   ψ^[[evar:E↦p]]^{evar:0↦x} using gpi
well_formed ψ^[[evar:E↦p]]^{evar:0↦?x}
Σ: Signature
Γ: Theory
E: evar
ψ: Pattern
x: evar
p, q: Pattern
gpi: ProofInfo
kt: bool
evs: coEVarSet
svs: coSVarSet
HxneqE: x ≠ E
wfψ: well_formed (ex , ψ)
wfp: well_formed p
wfq: well_formed q
Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Heqx2: x ∈ evs
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := kt) gpi
IH: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <--->
   ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH1: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} --->
   ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH2: Γ
⊢i ψ^[[evar:E↦q]]^{evar:0↦x} --->
   ψ^[[evar:E↦p]]^{evar:0↦x} using gpi
well_formed
  (ex , ψ^[[evar:E↦q]]) ^ [patt_free_evar ?y]
Σ: Signature
Γ: Theory
E: evar
ψ: Pattern
x: evar
p, q: Pattern
gpi: ProofInfo
kt: bool
evs: coEVarSet
svs: coSVarSet
HxneqE: x ≠ E
wfψ: well_formed (ex , ψ)
wfp: well_formed p
wfq: well_formed q
Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Heqx2: x ∈ evs
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := kt) gpi
IH: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <--->
   ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH1: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} --->
   ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH2: Γ
⊢i ψ^[[evar:E↦q]]^{evar:0↦x} --->
   ψ^[[evar:E↦p]]^{evar:0↦x} using gpi
well_formed (ex , ψ^[[evar:E↦q]])
Σ: Signature
Γ: Theory
E: evar
ψ: Pattern
x: evar
p, q: Pattern
gpi: ProofInfo
kt: bool
evs: coEVarSet
svs: coSVarSet
HxneqE: x ≠ E
wfψ: well_formed (ex , ψ)
wfp: well_formed p
wfq: well_formed q
Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Heqx2: x ∈ evs
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := kt) gpi
IH: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <--->
   ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH1: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} --->
   ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH2: Γ
⊢i ψ^[[evar:E↦q]]^{evar:0↦x} --->
   ψ^[[evar:E↦p]]^{evar:0↦x} using gpi
Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦
   ?x} --->
   (ex , ψ^[[evar:E↦q]]) ^ [patt_free_evar ?y]
using gpi
          4: {
Σ: Signature
Γ: Theory
E: evar
ψ: Pattern
x: evar
p, q: Pattern
gpi: ProofInfo
kt: bool
evs: coEVarSet
svs: coSVarSet
HxneqE: x ≠ E
wfψ: well_formed (ex , ψ)
wfp: well_formed p
wfq: well_formed q
Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Heqx2: x ∈ evs
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := kt) gpi
IH: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <--->
   ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH1: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} --->
   ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH2: Γ
⊢i ψ^[[evar:E↦q]]^{evar:0↦x} --->
   ψ^[[evar:E↦p]]^{evar:0↦x} using gpi
Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦?x} --->
   (ex , ψ^[[evar:E↦q]]) ^ [patt_free_evar ?y]
using gpi
              apply IH1.
            }
Σ: Signature
Γ: Theory
E: evar
ψ: Pattern
x: evar
p, q: Pattern
gpi: ProofInfo
kt: bool
evs: coEVarSet
svs: coSVarSet
HxneqE: x ≠ E
wfψ: well_formed (ex , ψ)
wfp: well_formed p
wfq: well_formed q
Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Heqx2: x ∈ evs
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := kt) gpi
IH: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <--->
   ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH1: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} --->
   ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH2: Γ
⊢i ψ^[[evar:E↦q]]^{evar:0↦x} --->
   ψ^[[evar:E↦p]]^{evar:0↦x} using gpi
well_formed ψ^[[evar:E↦p]]^{evar:0↦x}
Σ: Signature
Γ: Theory
E: evar
ψ: Pattern
x: evar
p, q: Pattern
gpi: ProofInfo
kt: bool
evs: coEVarSet
svs: coSVarSet
HxneqE: x ≠ E
wfψ: well_formed (ex , ψ)
wfp: well_formed p
wfq: well_formed q
Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Heqx2: x ∈ evs
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := kt) gpi
IH: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <--->
   ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH1: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} --->
   ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH2: Γ
⊢i ψ^[[evar:E↦q]]^{evar:0↦x} --->
   ψ^[[evar:E↦p]]^{evar:0↦x} using gpi
well_formed (ex , ψ^[[evar:E↦q]]) ^ [patt_free_evar x]
Σ: Signature
Γ: Theory
E: evar
ψ: Pattern
x: evar
p, q: Pattern
gpi: ProofInfo
kt: bool
evs: coEVarSet
svs: coSVarSet
HxneqE: x ≠ E
wfψ: well_formed (ex , ψ)
wfp: well_formed p
wfq: well_formed q
Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Heqx2: x ∈ evs
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := kt) gpi
IH: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <--->
   ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH1: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} --->
   ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH2: Γ
⊢i ψ^[[evar:E↦q]]^{evar:0↦x} --->
   ψ^[[evar:E↦p]]^{evar:0↦x} using gpi
well_formed (ex , ψ^[[evar:E↦q]])
          {
Σ: Signature
Γ: Theory
E: evar
ψ: Pattern
x: evar
p, q: Pattern
gpi: ProofInfo
kt: bool
evs: coEVarSet
svs: coSVarSet
HxneqE: x ≠ E
wfψ: well_formed (ex , ψ)
wfp: well_formed p
wfq: well_formed q
Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Heqx2: x ∈ evs
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := kt) gpi
IH: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <--->
   ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH1: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} --->
   ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH2: Γ
⊢i ψ^[[evar:E↦q]]^{evar:0↦x} --->
   ψ^[[evar:E↦p]]^{evar:0↦x} using gpi
well_formed ψ^[[evar:E↦p]]^{evar:0↦x} abstract (wf_auto2). }
Σ: Signature
Γ: Theory
E: evar
ψ: Pattern
x: evar
p, q: Pattern
gpi: ProofInfo
kt: bool
evs: coEVarSet
svs: coSVarSet
HxneqE: x ≠ E
wfψ: well_formed (ex , ψ)
wfp: well_formed p
wfq: well_formed q
Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Heqx2: x ∈ evs
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := kt) gpi
IH: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <--->
   ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH1: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} --->
   ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH2: Γ
⊢i ψ^[[evar:E↦q]]^{evar:0↦x} --->
   ψ^[[evar:E↦p]]^{evar:0↦x} using gpi
well_formed (ex , ψ^[[evar:E↦q]]) ^ [patt_free_evar x]
Σ: Signature
Γ: Theory
E: evar
ψ: Pattern
x: evar
p, q: Pattern
gpi: ProofInfo
kt: bool
evs: coEVarSet
svs: coSVarSet
HxneqE: x ≠ E
wfψ: well_formed (ex , ψ)
wfp: well_formed p
wfq: well_formed q
Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Heqx2: x ∈ evs
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := kt) gpi
IH: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <--->
   ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH1: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} --->
   ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH2: Γ
⊢i ψ^[[evar:E↦q]]^{evar:0↦x} --->
   ψ^[[evar:E↦p]]^{evar:0↦x} using gpi
well_formed (ex , ψ^[[evar:E↦q]])
          {
Σ: Signature
Γ: Theory
E: evar
ψ: Pattern
x: evar
p, q: Pattern
gpi: ProofInfo
kt: bool
evs: coEVarSet
svs: coSVarSet
HxneqE: x ≠ E
wfψ: well_formed (ex , ψ)
wfp: well_formed p
wfq: well_formed q
Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Heqx2: x ∈ evs
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := kt) gpi
IH: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <--->
   ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH1: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} --->
   ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH2: Γ
⊢i ψ^[[evar:E↦q]]^{evar:0↦x} --->
   ψ^[[evar:E↦p]]^{evar:0↦x} using gpi
well_formed (ex , ψ^[[evar:E↦q]]) ^ [patt_free_evar x] abstract (simpl; wf_auto2; apply wfc_ex_aux_bevar_subst; wf_auto2). }
Σ: Signature
Γ: Theory
E: evar
ψ: Pattern
x: evar
p, q: Pattern
gpi: ProofInfo
kt: bool
evs: coEVarSet
svs: coSVarSet
HxneqE: x ≠ E
wfψ: well_formed (ex , ψ)
wfp: well_formed p
wfq: well_formed q
Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Heqx2: x ∈ evs
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := kt) gpi
IH: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <--->
   ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH1: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} --->
   ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH2: Γ
⊢i ψ^[[evar:E↦q]]^{evar:0↦x} --->
   ψ^[[evar:E↦p]]^{evar:0↦x} using gpi
well_formed (ex , ψ^[[evar:E↦q]])
          {
Σ: Signature
Γ: Theory
E: evar
ψ: Pattern
x: evar
p, q: Pattern
gpi: ProofInfo
kt: bool
evs: coEVarSet
svs: coSVarSet
HxneqE: x ≠ E
wfψ: well_formed (ex , ψ)
wfp: well_formed p
wfq: well_formed q
Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Heqx2: x ∈ evs
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := kt) gpi
IH: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <--->
   ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH1: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} --->
   ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH2: Γ
⊢i ψ^[[evar:E↦q]]^{evar:0↦x} --->
   ψ^[[evar:E↦p]]^{evar:0↦x} using gpi
well_formed (ex , ψ^[[evar:E↦q]]) abstract (wf_auto2). }
        }
Σ: Signature
Γ: Theory
E: evar
ψ: Pattern
x: evar
p, q: Pattern
gpi: ProofInfo
kt: bool
evs: coEVarSet
svs: coSVarSet
HxneqE: x ≠ E
wfψ: well_formed (ex , ψ)
wfp: well_formed p
wfq: well_formed q
Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Heqx2: x ∈ evs
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := kt) gpi
IH: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <--->
   ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH1: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} --->
   ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH2: Γ
⊢i ψ^[[evar:E↦q]]^{evar:0↦x} --->
   ψ^[[evar:E↦p]]^{evar:0↦x} using gpi
ProofInfoLe
  (ExGen := {[x]}, SVSubst := ∅, KT := false) gpi
Σ: Signature
Γ: Theory
E: evar
ψ: Pattern
x: evar
p, q: Pattern
gpi: ProofInfo
kt: bool
evs: coEVarSet
svs: coSVarSet
HxneqE: x ≠ E
wfψ: well_formed (ex , ψ)
wfp: well_formed p
wfq: well_formed q
Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Heqx2: x ∈ evs
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := kt) gpi
IH: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <--->
   ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH1: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} --->
   ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH2: Γ
⊢i ψ^[[evar:E↦q]]^{evar:0↦x} --->
   ψ^[[evar:E↦p]]^{evar:0↦x} using gpi
x ∉ free_evars (ex , ψ^[[evar:E↦q]])
        {
Σ: Signature
Γ: Theory
E: evar
ψ: Pattern
x: evar
p, q: Pattern
gpi: ProofInfo
kt: bool
evs: coEVarSet
svs: coSVarSet
HxneqE: x ≠ E
wfψ: well_formed (ex , ψ)
wfp: well_formed p
wfq: well_formed q
Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Heqx2: x ∈ evs
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := kt) gpi
IH: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <--->
   ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH1: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} --->
   ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH2: Γ
⊢i ψ^[[evar:E↦q]]^{evar:0↦x} --->
   ψ^[[evar:E↦p]]^{evar:0↦x} using gpi
ProofInfoLe
  (ExGen := {[x]}, SVSubst := ∅, KT := false) gpi
          abstract (
            eapply pile_trans;
            [|apply pile];
            split; simpl; [|split; auto; set_solver];
            set_solver
          ).
        }
Σ: Signature
Γ: Theory
E: evar
ψ: Pattern
x: evar
p, q: Pattern
gpi: ProofInfo
kt: bool
evs: coEVarSet
svs: coSVarSet
HxneqE: x ≠ E
wfψ: well_formed (ex , ψ)
wfp: well_formed p
wfq: well_formed q
Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Heqx2: x ∈ evs
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := kt) gpi
IH: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <--->
   ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH1: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} --->
   ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH2: Γ
⊢i ψ^[[evar:E↦q]]^{evar:0↦x} --->
   ψ^[[evar:E↦p]]^{evar:0↦x} using gpi
x ∉ free_evars (ex , ψ^[[evar:E↦q]])
        {
Σ: Signature
Γ: Theory
E: evar
ψ: Pattern
x: evar
p, q: Pattern
gpi: ProofInfo
kt: bool
evs: coEVarSet
svs: coSVarSet
HxneqE: x ≠ E
wfψ: well_formed (ex , ψ)
wfp: well_formed p
wfq: well_formed q
Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Heqx2: x ∈ evs
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := kt) gpi
IH: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <--->
   ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH1: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} --->
   ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH2: Γ
⊢i ψ^[[evar:E↦q]]^{evar:0↦x} --->
   ψ^[[evar:E↦p]]^{evar:0↦x} using gpi
x ∉ free_evars (ex , ψ^[[evar:E↦q]])
          abstract (
            pose proof (Htmp2 := free_evars_free_evar_subst ψ q E);
            set_solver
          ).
        }
      }
Σ: Signature
Γ: Theory
E: evar
ψ: Pattern
x: evar
p, q: Pattern
gpi: ProofInfo
kt: bool
evs: coEVarSet
svs: coSVarSet
HxneqE: x ≠ E
wfψ: well_formed (ex , ψ)
wfp: well_formed p
wfq: well_formed q
Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Heqx2: x ∈ evs
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := kt) gpi
IH: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <--->
   ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH1: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} --->
   ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH2: Γ
⊢i ψ^[[evar:E↦q]]^{evar:0↦x} --->
   ψ^[[evar:E↦p]]^{evar:0↦x} using gpi
x ∉ free_evars ψ^[[evar:E↦p]]
Σ: Signature
Γ: Theory
E: evar
ψ: Pattern
x: evar
p, q: Pattern
gpi: ProofInfo
kt: bool
evs: coEVarSet
svs: coSVarSet
HxneqE: x ≠ E
wfψ: well_formed (ex , ψ)
wfp: well_formed p
wfq: well_formed q
Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Heqx2: x ∈ evs
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := kt) gpi
IH: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <--->
   ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH1: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} --->
   ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH2: Γ
⊢i ψ^[[evar:E↦q]]^{evar:0↦x} --->
   ψ^[[evar:E↦p]]^{evar:0↦x} using gpi
well_formed_closed_ex_aux ψ^[[evar:E↦p]] 1
      {
Σ: Signature
Γ: Theory
E: evar
ψ: Pattern
x: evar
p, q: Pattern
gpi: ProofInfo
kt: bool
evs: coEVarSet
svs: coSVarSet
HxneqE: x ≠ E
wfψ: well_formed (ex , ψ)
wfp: well_formed p
wfq: well_formed q
Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Heqx2: x ∈ evs
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := kt) gpi
IH: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <--->
   ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH1: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} --->
   ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH2: Γ
⊢i ψ^[[evar:E↦q]]^{evar:0↦x} --->
   ψ^[[evar:E↦p]]^{evar:0↦x} using gpi
x ∉ free_evars ψ^[[evar:E↦p]]
        abstract (
          pose proof (Htmp2 := free_evars_free_evar_subst ψ p E);
          set_solver
        ).
      }
Σ: Signature
Γ: Theory
E: evar
ψ: Pattern
x: evar
p, q: Pattern
gpi: ProofInfo
kt: bool
evs: coEVarSet
svs: coSVarSet
HxneqE: x ≠ E
wfψ: well_formed (ex , ψ)
wfp: well_formed p
wfq: well_formed q
Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Heqx2: x ∈ evs
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := kt) gpi
IH: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <--->
   ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH1: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} --->
   ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH2: Γ
⊢i ψ^[[evar:E↦q]]^{evar:0↦x} --->
   ψ^[[evar:E↦p]]^{evar:0↦x} using gpi
well_formed_closed_ex_aux ψ^[[evar:E↦p]] 1
      {
Σ: Signature
Γ: Theory
E: evar
ψ: Pattern
x: evar
p, q: Pattern
gpi: ProofInfo
kt: bool
evs: coEVarSet
svs: coSVarSet
HxneqE: x ≠ E
wfψ: well_formed (ex , ψ)
wfp: well_formed p
wfq: well_formed q
Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Heqx2: x ∈ evs
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := kt) gpi
IH: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <--->
   ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH1: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} --->
   ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH2: Γ
⊢i ψ^[[evar:E↦q]]^{evar:0↦x} --->
   ψ^[[evar:E↦p]]^{evar:0↦x} using gpi
well_formed_closed_ex_aux ψ^[[evar:E↦p]] 1
        wf_auto2.
      }
    }
Σ: Signature
Γ: Theory
E: evar
ψ: Pattern
x: evar
p, q: Pattern
gpi: ProofInfo
kt: bool
evs: coEVarSet
svs: coSVarSet
HxneqE: x ≠ E
wfψ: well_formed (ex , ψ)
wfp: well_formed p
wfq: well_formed q
Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Heqx2: x ∈ evs
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := kt) gpi
IH: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <--->
   ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH1: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} --->
   ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH2: Γ
⊢i ψ^[[evar:E↦q]]^{evar:0↦x} --->
   ψ^[[evar:E↦p]]^{evar:0↦x} using gpi
Γ ⊢i (ex , ψ^[[evar:E↦q]]) ---> (ex , ψ^[[evar:E↦p]])
using gpi
    (* this block is a symmetric version of the previous block*)
    {
Σ: Signature
Γ: Theory
E: evar
ψ: Pattern
x: evar
p, q: Pattern
gpi: ProofInfo
kt: bool
evs: coEVarSet
svs: coSVarSet
HxneqE: x ≠ E
wfψ: well_formed (ex , ψ)
wfp: well_formed p
wfq: well_formed q
Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Heqx2: x ∈ evs
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := kt) gpi
IH: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <--->
   ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH1: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} --->
   ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH2: Γ
⊢i ψ^[[evar:E↦q]]^{evar:0↦x} --->
   ψ^[[evar:E↦p]]^{evar:0↦x} using gpi
Γ ⊢i (ex , ψ^[[evar:E↦q]]) ---> (ex , ψ^[[evar:E↦p]])
using gpi
      eapply strip_exists_quantify_l.
Σ: Signature
Γ: Theory
E: evar
ψ: Pattern
x: evar
p, q: Pattern
gpi: ProofInfo
kt: bool
evs: coEVarSet
svs: coSVarSet
HxneqE: x ≠ E
wfψ: well_formed (ex , ψ)
wfp: well_formed p
wfq: well_formed q
Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Heqx2: x ∈ evs
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := kt) gpi
IH: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <--->
   ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH1: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} --->
   ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH2: Γ
⊢i ψ^[[evar:E↦q]]^{evar:0↦x} --->
   ψ^[[evar:E↦p]]^{evar:0↦x} using gpi
?x ∉ free_evars ψ^[[evar:E↦q]]
Σ: Signature
Γ: Theory
E: evar
ψ: Pattern
x: evar
p, q: Pattern
gpi: ProofInfo
kt: bool
evs: coEVarSet
svs: coSVarSet
HxneqE: x ≠ E
wfψ: well_formed (ex , ψ)
wfp: well_formed p
wfq: well_formed q
Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Heqx2: x ∈ evs
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := kt) gpi
IH: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <--->
   ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH1: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} --->
   ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH2: Γ
⊢i ψ^[[evar:E↦q]]^{evar:0↦x} --->
   ψ^[[evar:E↦p]]^{evar:0↦x} using gpi
well_formed_closed_ex_aux ψ^[[evar:E↦q]] 1
Σ: Signature
Γ: Theory
E: evar
ψ: Pattern
x: evar
p, q: Pattern
gpi: ProofInfo
kt: bool
evs: coEVarSet
svs: coSVarSet
HxneqE: x ≠ E
wfψ: well_formed (ex , ψ)
wfp: well_formed p
wfq: well_formed q
Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Heqx2: x ∈ evs
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := kt) gpi
IH: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <--->
   ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH1: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} --->
   ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH2: Γ
⊢i ψ^[[evar:E↦q]]^{evar:0↦x} --->
   ψ^[[evar:E↦p]]^{evar:0↦x} using gpi
Γ
⊢i exists_quantify ?x ψ^[[evar:E↦q]]^{evar:0↦?x} --->
   (ex , ψ^[[evar:E↦p]]) using gpi
      3: {
Σ: Signature
Γ: Theory
E: evar
ψ: Pattern
x: evar
p, q: Pattern
gpi: ProofInfo
kt: bool
evs: coEVarSet
svs: coSVarSet
HxneqE: x ≠ E
wfψ: well_formed (ex , ψ)
wfp: well_formed p
wfq: well_formed q
Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Heqx2: x ∈ evs
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := kt) gpi
IH: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <--->
   ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH1: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} --->
   ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH2: Γ
⊢i ψ^[[evar:E↦q]]^{evar:0↦x} --->
   ψ^[[evar:E↦p]]^{evar:0↦x} using gpi
Γ
⊢i exists_quantify ?x ψ^[[evar:E↦q]]^{evar:0↦?x} --->
   (ex , ψ^[[evar:E↦p]]) using gpi
        apply Ex_gen.
Σ: Signature
Γ: Theory
E: evar
ψ: Pattern
x: evar
p, q: Pattern
gpi: ProofInfo
kt: bool
evs: coEVarSet
svs: coSVarSet
HxneqE: x ≠ E
wfψ: well_formed (ex , ψ)
wfp: well_formed p
wfq: well_formed q
Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Heqx2: x ∈ evs
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := kt) gpi
IH: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <--->
   ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH1: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} --->
   ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH2: Γ
⊢i ψ^[[evar:E↦q]]^{evar:0↦x} --->
   ψ^[[evar:E↦p]]^{evar:0↦x} using gpi
ProofInfoLe
  (ExGen := {[?x]}, SVSubst := ∅, KT := false) gpi
Σ: Signature
Γ: Theory
E: evar
ψ: Pattern
x: evar
p, q: Pattern
gpi: ProofInfo
kt: bool
evs: coEVarSet
svs: coSVarSet
HxneqE: x ≠ E
wfψ: well_formed (ex , ψ)
wfp: well_formed p
wfq: well_formed q
Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Heqx2: x ∈ evs
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := kt) gpi
IH: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <--->
   ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH1: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} --->
   ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH2: Γ
⊢i ψ^[[evar:E↦q]]^{evar:0↦x} --->
   ψ^[[evar:E↦p]]^{evar:0↦x} using gpi
?x ∉ free_evars (ex , ψ^[[evar:E↦p]])
Σ: Signature
Γ: Theory
E: evar
ψ: Pattern
x: evar
p, q: Pattern
gpi: ProofInfo
kt: bool
evs: coEVarSet
svs: coSVarSet
HxneqE: x ≠ E
wfψ: well_formed (ex , ψ)
wfp: well_formed p
wfq: well_formed q
Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Heqx2: x ∈ evs
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := kt) gpi
IH: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <--->
   ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH1: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} --->
   ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH2: Γ
⊢i ψ^[[evar:E↦q]]^{evar:0↦x} --->
   ψ^[[evar:E↦p]]^{evar:0↦x} using gpi
Γ
⊢i ψ^[[evar:E↦q]]^{evar:0↦
   ?x} ---> (ex , ψ^[[evar:E↦p]]) using gpi
        3: {
Σ: Signature
Γ: Theory
E: evar
ψ: Pattern
x: evar
p, q: Pattern
gpi: ProofInfo
kt: bool
evs: coEVarSet
svs: coSVarSet
HxneqE: x ≠ E
wfψ: well_formed (ex , ψ)
wfp: well_formed p
wfq: well_formed q
Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Heqx2: x ∈ evs
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := kt) gpi
IH: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <--->
   ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH1: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} --->
   ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH2: Γ
⊢i ψ^[[evar:E↦q]]^{evar:0↦x} --->
   ψ^[[evar:E↦p]]^{evar:0↦x} using gpi
Γ
⊢i ψ^[[evar:E↦q]]^{evar:0↦?x} --->
   (ex , ψ^[[evar:E↦p]]) using gpi
          eapply syllogism_meta.
Σ: Signature
Γ: Theory
E: evar
ψ: Pattern
x: evar
p, q: Pattern
gpi: ProofInfo
kt: bool
evs: coEVarSet
svs: coSVarSet
HxneqE: x ≠ E
wfψ: well_formed (ex , ψ)
wfp: well_formed p
wfq: well_formed q
Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Heqx2: x ∈ evs
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := kt) gpi
IH: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <--->
   ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH1: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} --->
   ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH2: Γ
⊢i ψ^[[evar:E↦q]]^{evar:0↦x} --->
   ψ^[[evar:E↦p]]^{evar:0↦x} using gpi
well_formed ψ^[[evar:E↦q]]^{evar:0↦?x}
Σ: Signature
Γ: Theory
E: evar
ψ: Pattern
x: evar
p, q: Pattern
gpi: ProofInfo
kt: bool
evs: coEVarSet
svs: coSVarSet
HxneqE: x ≠ E
wfψ: well_formed (ex , ψ)
wfp: well_formed p
wfq: well_formed q
Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Heqx2: x ∈ evs
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := kt) gpi
IH: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <--->
   ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH1: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} --->
   ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH2: Γ
⊢i ψ^[[evar:E↦q]]^{evar:0↦x} --->
   ψ^[[evar:E↦p]]^{evar:0↦x} using gpi
well_formed ?B
Σ: Signature
Γ: Theory
E: evar
ψ: Pattern
x: evar
p, q: Pattern
gpi: ProofInfo
kt: bool
evs: coEVarSet
svs: coSVarSet
HxneqE: x ≠ E
wfψ: well_formed (ex , ψ)
wfp: well_formed p
wfq: well_formed q
Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Heqx2: x ∈ evs
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := kt) gpi
IH: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <--->
   ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH1: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} --->
   ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH2: Γ
⊢i ψ^[[evar:E↦q]]^{evar:0↦x} --->
   ψ^[[evar:E↦p]]^{evar:0↦x} using gpi
well_formed (ex , ψ^[[evar:E↦p]])
Σ: Signature
Γ: Theory
E: evar
ψ: Pattern
x: evar
p, q: Pattern
gpi: ProofInfo
kt: bool
evs: coEVarSet
svs: coSVarSet
HxneqE: x ≠ E
wfψ: well_formed (ex , ψ)
wfp: well_formed p
wfq: well_formed q
Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Heqx2: x ∈ evs
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := kt) gpi
IH: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <--->
   ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH1: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} --->
   ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH2: Γ
⊢i ψ^[[evar:E↦q]]^{evar:0↦x} --->
   ψ^[[evar:E↦p]]^{evar:0↦x} using gpi
Γ ⊢i ψ^[[evar:E↦q]]^{evar:0↦?x} ---> ?B using gpi
Σ: Signature
Γ: Theory
E: evar
ψ: Pattern
x: evar
p, q: Pattern
gpi: ProofInfo
kt: bool
evs: coEVarSet
svs: coSVarSet
HxneqE: x ≠ E
wfψ: well_formed (ex , ψ)
wfp: well_formed p
wfq: well_formed q
Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Heqx2: x ∈ evs
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := kt) gpi
IH: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <--->
   ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH1: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} --->
   ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH2: Γ
⊢i ψ^[[evar:E↦q]]^{evar:0↦x} --->
   ψ^[[evar:E↦p]]^{evar:0↦x} using gpi
Γ ⊢i ?B ---> (ex , ψ^[[evar:E↦p]]) using gpi
          5: {
Σ: Signature
Γ: Theory
E: evar
ψ: Pattern
x: evar
p, q: Pattern
gpi: ProofInfo
kt: bool
evs: coEVarSet
svs: coSVarSet
HxneqE: x ≠ E
wfψ: well_formed (ex , ψ)
wfp: well_formed p
wfq: well_formed q
Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Heqx2: x ∈ evs
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := kt) gpi
IH: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <--->
   ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH1: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} --->
   ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH2: Γ
⊢i ψ^[[evar:E↦q]]^{evar:0↦x} --->
   ψ^[[evar:E↦p]]^{evar:0↦x} using gpi
Γ ⊢i ?B ---> (ex , ψ^[[evar:E↦p]]) using gpi
            useBasicReasoning.
Σ: Signature
Γ: Theory
E: evar
ψ: Pattern
x: evar
p, q: Pattern
gpi: ProofInfo
kt: bool
evs: coEVarSet
svs: coSVarSet
HxneqE: x ≠ E
wfψ: well_formed (ex , ψ)
wfp: well_formed p
wfq: well_formed q
Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Heqx2: x ∈ evs
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := kt) gpi
IH: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <--->
   ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH1: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} --->
   ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH2: Γ
⊢i ψ^[[evar:E↦q]]^{evar:0↦x} --->
   ψ^[[evar:E↦p]]^{evar:0↦x} using gpi
Γ ⊢i ?B ---> (ex , ψ^[[evar:E↦p]])
using BasicReasoning
            apply Ex_quan.
Σ: Signature
Γ: Theory
E: evar
ψ: Pattern
x: evar
p, q: Pattern
gpi: ProofInfo
kt: bool
evs: coEVarSet
svs: coSVarSet
HxneqE: x ≠ E
wfψ: well_formed (ex , ψ)
wfp: well_formed p
wfq: well_formed q
Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Heqx2: x ∈ evs
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := kt) gpi
IH: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <--->
   ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH1: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} --->
   ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH2: Γ
⊢i ψ^[[evar:E↦q]]^{evar:0↦x} --->
   ψ^[[evar:E↦p]]^{evar:0↦x} using gpi
well_formed (ex , ψ^[[evar:E↦p]])
            abstract (wf_auto2).
          }
Σ: Signature
Γ: Theory
E: evar
ψ: Pattern
x: evar
p, q: Pattern
gpi: ProofInfo
kt: bool
evs: coEVarSet
svs: coSVarSet
HxneqE: x ≠ E
wfψ: well_formed (ex , ψ)
wfp: well_formed p
wfq: well_formed q
Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Heqx2: x ∈ evs
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := kt) gpi
IH: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <--->
   ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH1: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} --->
   ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH2: Γ
⊢i ψ^[[evar:E↦q]]^{evar:0↦x} --->
   ψ^[[evar:E↦p]]^{evar:0↦x} using gpi
well_formed ψ^[[evar:E↦q]]^{evar:0↦?x}
Σ: Signature
Γ: Theory
E: evar
ψ: Pattern
x: evar
p, q: Pattern
gpi: ProofInfo
kt: bool
evs: coEVarSet
svs: coSVarSet
HxneqE: x ≠ E
wfψ: well_formed (ex , ψ)
wfp: well_formed p
wfq: well_formed q
Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Heqx2: x ∈ evs
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := kt) gpi
IH: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <--->
   ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH1: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} --->
   ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH2: Γ
⊢i ψ^[[evar:E↦q]]^{evar:0↦x} --->
   ψ^[[evar:E↦p]]^{evar:0↦x} using gpi
well_formed
  (ex , ψ^[[evar:E↦p]]) ^ [patt_free_evar ?y]
Σ: Signature
Γ: Theory
E: evar
ψ: Pattern
x: evar
p, q: Pattern
gpi: ProofInfo
kt: bool
evs: coEVarSet
svs: coSVarSet
HxneqE: x ≠ E
wfψ: well_formed (ex , ψ)
wfp: well_formed p
wfq: well_formed q
Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Heqx2: x ∈ evs
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := kt) gpi
IH: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <--->
   ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH1: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} --->
   ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH2: Γ
⊢i ψ^[[evar:E↦q]]^{evar:0↦x} --->
   ψ^[[evar:E↦p]]^{evar:0↦x} using gpi
well_formed (ex , ψ^[[evar:E↦p]])
Σ: Signature
Γ: Theory
E: evar
ψ: Pattern
x: evar
p, q: Pattern
gpi: ProofInfo
kt: bool
evs: coEVarSet
svs: coSVarSet
HxneqE: x ≠ E
wfψ: well_formed (ex , ψ)
wfp: well_formed p
wfq: well_formed q
Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Heqx2: x ∈ evs
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := kt) gpi
IH: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <--->
   ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH1: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} --->
   ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH2: Γ
⊢i ψ^[[evar:E↦q]]^{evar:0↦x} --->
   ψ^[[evar:E↦p]]^{evar:0↦x} using gpi
Γ
⊢i ψ^[[evar:E↦q]]^{evar:0↦
   ?x} --->
   (ex , ψ^[[evar:E↦p]]) ^ [patt_free_evar ?y]
using gpi
          4: {
Σ: Signature
Γ: Theory
E: evar
ψ: Pattern
x: evar
p, q: Pattern
gpi: ProofInfo
kt: bool
evs: coEVarSet
svs: coSVarSet
HxneqE: x ≠ E
wfψ: well_formed (ex , ψ)
wfp: well_formed p
wfq: well_formed q
Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Heqx2: x ∈ evs
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := kt) gpi
IH: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <--->
   ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH1: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} --->
   ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH2: Γ
⊢i ψ^[[evar:E↦q]]^{evar:0↦x} --->
   ψ^[[evar:E↦p]]^{evar:0↦x} using gpi
Γ
⊢i ψ^[[evar:E↦q]]^{evar:0↦?x} --->
   (ex , ψ^[[evar:E↦p]]) ^ [patt_free_evar ?y]
using gpi
              apply IH2.
            }
Σ: Signature
Γ: Theory
E: evar
ψ: Pattern
x: evar
p, q: Pattern
gpi: ProofInfo
kt: bool
evs: coEVarSet
svs: coSVarSet
HxneqE: x ≠ E
wfψ: well_formed (ex , ψ)
wfp: well_formed p
wfq: well_formed q
Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Heqx2: x ∈ evs
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := kt) gpi
IH: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <--->
   ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH1: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} --->
   ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH2: Γ
⊢i ψ^[[evar:E↦q]]^{evar:0↦x} --->
   ψ^[[evar:E↦p]]^{evar:0↦x} using gpi
well_formed ψ^[[evar:E↦q]]^{evar:0↦x}
Σ: Signature
Γ: Theory
E: evar
ψ: Pattern
x: evar
p, q: Pattern
gpi: ProofInfo
kt: bool
evs: coEVarSet
svs: coSVarSet
HxneqE: x ≠ E
wfψ: well_formed (ex , ψ)
wfp: well_formed p
wfq: well_formed q
Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Heqx2: x ∈ evs
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := kt) gpi
IH: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <--->
   ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH1: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} --->
   ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH2: Γ
⊢i ψ^[[evar:E↦q]]^{evar:0↦x} --->
   ψ^[[evar:E↦p]]^{evar:0↦x} using gpi
well_formed (ex , ψ^[[evar:E↦p]]) ^ [patt_free_evar x]
Σ: Signature
Γ: Theory
E: evar
ψ: Pattern
x: evar
p, q: Pattern
gpi: ProofInfo
kt: bool
evs: coEVarSet
svs: coSVarSet
HxneqE: x ≠ E
wfψ: well_formed (ex , ψ)
wfp: well_formed p
wfq: well_formed q
Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Heqx2: x ∈ evs
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := kt) gpi
IH: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <--->
   ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH1: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} --->
   ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH2: Γ
⊢i ψ^[[evar:E↦q]]^{evar:0↦x} --->
   ψ^[[evar:E↦p]]^{evar:0↦x} using gpi
well_formed (ex , ψ^[[evar:E↦p]])
          {
Σ: Signature
Γ: Theory
E: evar
ψ: Pattern
x: evar
p, q: Pattern
gpi: ProofInfo
kt: bool
evs: coEVarSet
svs: coSVarSet
HxneqE: x ≠ E
wfψ: well_formed (ex , ψ)
wfp: well_formed p
wfq: well_formed q
Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Heqx2: x ∈ evs
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := kt) gpi
IH: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <--->
   ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH1: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} --->
   ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH2: Γ
⊢i ψ^[[evar:E↦q]]^{evar:0↦x} --->
   ψ^[[evar:E↦p]]^{evar:0↦x} using gpi
well_formed ψ^[[evar:E↦q]]^{evar:0↦x} abstract (wf_auto2). }
Σ: Signature
Γ: Theory
E: evar
ψ: Pattern
x: evar
p, q: Pattern
gpi: ProofInfo
kt: bool
evs: coEVarSet
svs: coSVarSet
HxneqE: x ≠ E
wfψ: well_formed (ex , ψ)
wfp: well_formed p
wfq: well_formed q
Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Heqx2: x ∈ evs
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := kt) gpi
IH: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <--->
   ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH1: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} --->
   ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH2: Γ
⊢i ψ^[[evar:E↦q]]^{evar:0↦x} --->
   ψ^[[evar:E↦p]]^{evar:0↦x} using gpi
well_formed (ex , ψ^[[evar:E↦p]]) ^ [patt_free_evar x]
Σ: Signature
Γ: Theory
E: evar
ψ: Pattern
x: evar
p, q: Pattern
gpi: ProofInfo
kt: bool
evs: coEVarSet
svs: coSVarSet
HxneqE: x ≠ E
wfψ: well_formed (ex , ψ)
wfp: well_formed p
wfq: well_formed q
Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Heqx2: x ∈ evs
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := kt) gpi
IH: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <--->
   ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH1: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} --->
   ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH2: Γ
⊢i ψ^[[evar:E↦q]]^{evar:0↦x} --->
   ψ^[[evar:E↦p]]^{evar:0↦x} using gpi
well_formed (ex , ψ^[[evar:E↦p]])
          {
Σ: Signature
Γ: Theory
E: evar
ψ: Pattern
x: evar
p, q: Pattern
gpi: ProofInfo
kt: bool
evs: coEVarSet
svs: coSVarSet
HxneqE: x ≠ E
wfψ: well_formed (ex , ψ)
wfp: well_formed p
wfq: well_formed q
Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Heqx2: x ∈ evs
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := kt) gpi
IH: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <--->
   ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH1: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} --->
   ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH2: Γ
⊢i ψ^[[evar:E↦q]]^{evar:0↦x} --->
   ψ^[[evar:E↦p]]^{evar:0↦x} using gpi
well_formed (ex , ψ^[[evar:E↦p]]) ^ [patt_free_evar x] abstract (simpl; wf_auto2; apply wfc_ex_aux_bevar_subst; wf_auto2). }
Σ: Signature
Γ: Theory
E: evar
ψ: Pattern
x: evar
p, q: Pattern
gpi: ProofInfo
kt: bool
evs: coEVarSet
svs: coSVarSet
HxneqE: x ≠ E
wfψ: well_formed (ex , ψ)
wfp: well_formed p
wfq: well_formed q
Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Heqx2: x ∈ evs
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := kt) gpi
IH: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <--->
   ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH1: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} --->
   ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH2: Γ
⊢i ψ^[[evar:E↦q]]^{evar:0↦x} --->
   ψ^[[evar:E↦p]]^{evar:0↦x} using gpi
well_formed (ex , ψ^[[evar:E↦p]])
          {
Σ: Signature
Γ: Theory
E: evar
ψ: Pattern
x: evar
p, q: Pattern
gpi: ProofInfo
kt: bool
evs: coEVarSet
svs: coSVarSet
HxneqE: x ≠ E
wfψ: well_formed (ex , ψ)
wfp: well_formed p
wfq: well_formed q
Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Heqx2: x ∈ evs
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := kt) gpi
IH: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <--->
   ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH1: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} --->
   ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH2: Γ
⊢i ψ^[[evar:E↦q]]^{evar:0↦x} --->
   ψ^[[evar:E↦p]]^{evar:0↦x} using gpi
well_formed (ex , ψ^[[evar:E↦p]]) abstract (wf_auto2). }
        }
Σ: Signature
Γ: Theory
E: evar
ψ: Pattern
x: evar
p, q: Pattern
gpi: ProofInfo
kt: bool
evs: coEVarSet
svs: coSVarSet
HxneqE: x ≠ E
wfψ: well_formed (ex , ψ)
wfp: well_formed p
wfq: well_formed q
Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Heqx2: x ∈ evs
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := kt) gpi
IH: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <--->
   ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH1: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} --->
   ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH2: Γ
⊢i ψ^[[evar:E↦q]]^{evar:0↦x} --->
   ψ^[[evar:E↦p]]^{evar:0↦x} using gpi
ProofInfoLe
  (ExGen := {[x]}, SVSubst := ∅, KT := false) gpi
Σ: Signature
Γ: Theory
E: evar
ψ: Pattern
x: evar
p, q: Pattern
gpi: ProofInfo
kt: bool
evs: coEVarSet
svs: coSVarSet
HxneqE: x ≠ E
wfψ: well_formed (ex , ψ)
wfp: well_formed p
wfq: well_formed q
Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Heqx2: x ∈ evs
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := kt) gpi
IH: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <--->
   ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH1: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} --->
   ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH2: Γ
⊢i ψ^[[evar:E↦q]]^{evar:0↦x} --->
   ψ^[[evar:E↦p]]^{evar:0↦x} using gpi
x ∉ free_evars (ex , ψ^[[evar:E↦p]])
        {
Σ: Signature
Γ: Theory
E: evar
ψ: Pattern
x: evar
p, q: Pattern
gpi: ProofInfo
kt: bool
evs: coEVarSet
svs: coSVarSet
HxneqE: x ≠ E
wfψ: well_formed (ex , ψ)
wfp: well_formed p
wfq: well_formed q
Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Heqx2: x ∈ evs
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := kt) gpi
IH: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <--->
   ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH1: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} --->
   ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH2: Γ
⊢i ψ^[[evar:E↦q]]^{evar:0↦x} --->
   ψ^[[evar:E↦p]]^{evar:0↦x} using gpi
ProofInfoLe
  (ExGen := {[x]}, SVSubst := ∅, KT := false) gpi
          abstract (
            eapply pile_trans;
            [|apply pile];
            split; simpl; [|split; auto; set_solver];
            set_solver
          ).
        }
Σ: Signature
Γ: Theory
E: evar
ψ: Pattern
x: evar
p, q: Pattern
gpi: ProofInfo
kt: bool
evs: coEVarSet
svs: coSVarSet
HxneqE: x ≠ E
wfψ: well_formed (ex , ψ)
wfp: well_formed p
wfq: well_formed q
Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Heqx2: x ∈ evs
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := kt) gpi
IH: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <--->
   ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH1: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} --->
   ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH2: Γ
⊢i ψ^[[evar:E↦q]]^{evar:0↦x} --->
   ψ^[[evar:E↦p]]^{evar:0↦x} using gpi
x ∉ free_evars (ex , ψ^[[evar:E↦p]])
        {
Σ: Signature
Γ: Theory
E: evar
ψ: Pattern
x: evar
p, q: Pattern
gpi: ProofInfo
kt: bool
evs: coEVarSet
svs: coSVarSet
HxneqE: x ≠ E
wfψ: well_formed (ex , ψ)
wfp: well_formed p
wfq: well_formed q
Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Heqx2: x ∈ evs
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := kt) gpi
IH: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <--->
   ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH1: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} --->
   ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH2: Γ
⊢i ψ^[[evar:E↦q]]^{evar:0↦x} --->
   ψ^[[evar:E↦p]]^{evar:0↦x} using gpi
x ∉ free_evars (ex , ψ^[[evar:E↦p]])
          abstract (
            pose proof (Htmp2 := free_evars_free_evar_subst ψ p E);
            set_solver
          ).
        }
      }
Σ: Signature
Γ: Theory
E: evar
ψ: Pattern
x: evar
p, q: Pattern
gpi: ProofInfo
kt: bool
evs: coEVarSet
svs: coSVarSet
HxneqE: x ≠ E
wfψ: well_formed (ex , ψ)
wfp: well_formed p
wfq: well_formed q
Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Heqx2: x ∈ evs
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := kt) gpi
IH: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <--->
   ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH1: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} --->
   ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH2: Γ
⊢i ψ^[[evar:E↦q]]^{evar:0↦x} --->
   ψ^[[evar:E↦p]]^{evar:0↦x} using gpi
x ∉ free_evars ψ^[[evar:E↦q]]
Σ: Signature
Γ: Theory
E: evar
ψ: Pattern
x: evar
p, q: Pattern
gpi: ProofInfo
kt: bool
evs: coEVarSet
svs: coSVarSet
HxneqE: x ≠ E
wfψ: well_formed (ex , ψ)
wfp: well_formed p
wfq: well_formed q
Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Heqx2: x ∈ evs
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := kt) gpi
IH: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <--->
   ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH1: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} --->
   ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH2: Γ
⊢i ψ^[[evar:E↦q]]^{evar:0↦x} --->
   ψ^[[evar:E↦p]]^{evar:0↦x} using gpi
well_formed_closed_ex_aux ψ^[[evar:E↦q]] 1
      {
Σ: Signature
Γ: Theory
E: evar
ψ: Pattern
x: evar
p, q: Pattern
gpi: ProofInfo
kt: bool
evs: coEVarSet
svs: coSVarSet
HxneqE: x ≠ E
wfψ: well_formed (ex , ψ)
wfp: well_formed p
wfq: well_formed q
Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Heqx2: x ∈ evs
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := kt) gpi
IH: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <--->
   ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH1: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} --->
   ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH2: Γ
⊢i ψ^[[evar:E↦q]]^{evar:0↦x} --->
   ψ^[[evar:E↦p]]^{evar:0↦x} using gpi
x ∉ free_evars ψ^[[evar:E↦q]]
        abstract (
          pose proof (Htmp2 := free_evars_free_evar_subst ψ q E);
          set_solver
        ).
      }
Σ: Signature
Γ: Theory
E: evar
ψ: Pattern
x: evar
p, q: Pattern
gpi: ProofInfo
kt: bool
evs: coEVarSet
svs: coSVarSet
HxneqE: x ≠ E
wfψ: well_formed (ex , ψ)
wfp: well_formed p
wfq: well_formed q
Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Heqx2: x ∈ evs
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := kt) gpi
IH: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <--->
   ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH1: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} --->
   ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH2: Γ
⊢i ψ^[[evar:E↦q]]^{evar:0↦x} --->
   ψ^[[evar:E↦p]]^{evar:0↦x} using gpi
well_formed_closed_ex_aux ψ^[[evar:E↦q]] 1
      {
Σ: Signature
Γ: Theory
E: evar
ψ: Pattern
x: evar
p, q: Pattern
gpi: ProofInfo
kt: bool
evs: coEVarSet
svs: coSVarSet
HxneqE: x ≠ E
wfψ: well_formed (ex , ψ)
wfp: well_formed p
wfq: well_formed q
Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Heqx2: x ∈ evs
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := kt) gpi
IH: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <--->
   ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH1: Γ
⊢i ψ^[[evar:E↦p]]^{evar:0↦x} --->
   ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH2: Γ
⊢i ψ^[[evar:E↦q]]^{evar:0↦x} --->
   ψ^[[evar:E↦p]]^{evar:0↦x} using gpi
well_formed_closed_ex_aux ψ^[[evar:E↦q]] 1
        abstract (wf_auto2).
      }
    }
  Defined.

End FOL_helpers.

  Ltac pi_exact H := 
    lazymatch type of H with
    | ?H' =>
      lazymatch goal with
      | [|- ?g] =>
        (cut (H' = g);
        [(let H0 := fresh "H0" in intros H0; rewrite -H0; exact H)|
         (repeat f_equal; try reflexivity; try apply proof_irrel)])
      end
    end.

  Ltac pi_assumption :=
    match goal with
    | [H : _ |- _] => pi_exact H
    end.

  Ltac pi_set_solver := set_solver by (try pi_assumption).

Section FOL_helpers.

  Context {Σ : Signature}.

  Lemma congruence_app Γ ψ1 ψ2 p q E i
    (wfψ1: well_formed ψ1)
    (wfψ2: well_formed ψ2)
    (wfp: well_formed p)
    (wfq: well_formed q)
    (pf₁: Γ ⊢i ψ1^[[evar: E ↦ p]] <---> ψ1^[[evar: E ↦ q]] using i)
    (pf₂: Γ ⊢i ψ2^[[evar: E ↦ p]] <---> ψ2^[[evar: E ↦ q]] using i)
    :
    (Γ ⊢i (ψ1^[[evar: E ↦ p]]) $ (ψ2^[[evar: E ↦ p]]) <---> (ψ1^[[evar: E ↦ q]]) $ (ψ2^[[evar: E ↦ q]]) using i).
Σ: Signature
Γ: Theory
ψ1, ψ2, p, q: Pattern
E: evar
i: ProofInfo
wfψ1: well_formed ψ1
wfψ2: well_formed ψ2
wfp: well_formed p
wfq: well_formed q
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]]
using i
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]]
using i
Γ
⊢i ψ1^[[evar:E↦p]] $ ψ2^[[evar:E↦p]] <--->
   ψ1^[[evar:E↦q]] $ ψ2^[[evar:E↦q]] using i
  Proof.
Σ: Signature
Γ: Theory
ψ1, ψ2, p, q: Pattern
E: evar
i: ProofInfo
wfψ1: well_formed ψ1
wfψ2: well_formed ψ2
wfp: well_formed p
wfq: well_formed q
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]]
using i
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]]
using i
Γ
⊢i ψ1^[[evar:E↦p]] $ ψ2^[[evar:E↦p]] <--->
   ψ1^[[evar:E↦q]] $ ψ2^[[evar:E↦q]] using i
    remember (well_formed_free_evar_subst_0 E _ _ wfp wfψ1) as Hwf1.
Σ: Signature
Γ: Theory
ψ1, ψ2, p, q: Pattern
E: evar
i: ProofInfo
wfψ1: well_formed ψ1
wfψ2: well_formed ψ2
wfp: well_formed p
wfq: well_formed q
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]]
using i
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]]
using i
Hwf1: well_formed ψ1^[[evar:E↦p]] = true
HeqHwf1: Hwf1 =
well_formed_free_evar_subst_0 E ψ1 p wfp
  wfψ1
Γ
⊢i ψ1^[[evar:E↦p]] $ ψ2^[[evar:E↦p]] <--->
   ψ1^[[evar:E↦q]] $ ψ2^[[evar:E↦q]] using i
    remember (well_formed_free_evar_subst_0 E _ _ wfq wfψ1) as Hwf2.
Σ: Signature
Γ: Theory
ψ1, ψ2, p, q: Pattern
E: evar
i: ProofInfo
wfψ1: well_formed ψ1
wfψ2: well_formed ψ2
wfp: well_formed p
wfq: well_formed q
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]]
using i
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]]
using i
Hwf1: well_formed ψ1^[[evar:E↦p]] = true
HeqHwf1: Hwf1 =
well_formed_free_evar_subst_0 E ψ1 p wfp
  wfψ1
Hwf2: well_formed ψ1^[[evar:E↦q]] = true
HeqHwf2: Hwf2 =
well_formed_free_evar_subst_0 E ψ1 q wfq
  wfψ1
Γ
⊢i ψ1^[[evar:E↦p]] $ ψ2^[[evar:E↦p]] <--->
   ψ1^[[evar:E↦q]] $ ψ2^[[evar:E↦q]] using i
    remember (well_formed_free_evar_subst_0 E _ _ wfp wfψ2) as Hwf3.
Σ: Signature
Γ: Theory
ψ1, ψ2, p, q: Pattern
E: evar
i: ProofInfo
wfψ1: well_formed ψ1
wfψ2: well_formed ψ2
wfp: well_formed p
wfq: well_formed q
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]]
using i
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]]
using i
Hwf1: well_formed ψ1^[[evar:E↦p]] = true
HeqHwf1: Hwf1 =
well_formed_free_evar_subst_0 E ψ1 p wfp
  wfψ1
Hwf2: well_formed ψ1^[[evar:E↦q]] = true
HeqHwf2: Hwf2 =
well_formed_free_evar_subst_0 E ψ1 q wfq
  wfψ1
Hwf3: well_formed ψ2^[[evar:E↦p]] = true
HeqHwf3: Hwf3 =
well_formed_free_evar_subst_0 E ψ2 p wfp
  wfψ2
Γ
⊢i ψ1^[[evar:E↦p]] $ ψ2^[[evar:E↦p]] <--->
   ψ1^[[evar:E↦q]] $ ψ2^[[evar:E↦q]] using i
    remember (well_formed_free_evar_subst_0 E _ _ wfq wfψ2) as Hwf4.
Σ: Signature
Γ: Theory
ψ1, ψ2, p, q: Pattern
E: evar
i: ProofInfo
wfψ1: well_formed ψ1
wfψ2: well_formed ψ2
wfp: well_formed p
wfq: well_formed q
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]]
using i
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]]
using i
Hwf1: well_formed ψ1^[[evar:E↦p]] = true
HeqHwf1: Hwf1 =
well_formed_free_evar_subst_0 E ψ1 p wfp
  wfψ1
Hwf2: well_formed ψ1^[[evar:E↦q]] = true
HeqHwf2: Hwf2 =
well_formed_free_evar_subst_0 E ψ1 q wfq
  wfψ1
Hwf3: well_formed ψ2^[[evar:E↦p]] = true
HeqHwf3: Hwf3 =
well_formed_free_evar_subst_0 E ψ2 p wfp
  wfψ2
Hwf4: well_formed ψ2^[[evar:E↦q]] = true
HeqHwf4: Hwf4 =
well_formed_free_evar_subst_0 E ψ2 q wfq
  wfψ2
Γ
⊢i ψ1^[[evar:E↦p]] $ ψ2^[[evar:E↦p]] <--->
   ψ1^[[evar:E↦q]] $ ψ2^[[evar:E↦q]] using i

    eapply pf_iff_equiv_trans.
Σ: Signature
Γ: Theory
ψ1, ψ2, p, q: Pattern
E: evar
i: ProofInfo
wfψ1: well_formed ψ1
wfψ2: well_formed ψ2
wfp: well_formed p
wfq: well_formed q
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]]
using i
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]]
using i
Hwf1: well_formed ψ1^[[evar:E↦p]] = true
HeqHwf1: Hwf1 =
well_formed_free_evar_subst_0 E ψ1 p wfp
  wfψ1
Hwf2: well_formed ψ1^[[evar:E↦q]] = true
HeqHwf2: Hwf2 =
well_formed_free_evar_subst_0 E ψ1 q wfq
  wfψ1
Hwf3: well_formed ψ2^[[evar:E↦p]] = true
HeqHwf3: Hwf3 =
well_formed_free_evar_subst_0 E ψ2 p wfp
  wfψ2
Hwf4: well_formed ψ2^[[evar:E↦q]] = true
HeqHwf4: Hwf4 =
well_formed_free_evar_subst_0 E ψ2 q wfq
  wfψ2
well_formed (ψ1^[[evar:E↦p]] $ ψ2^[[evar:E↦p]])
Σ: Signature
Γ: Theory
ψ1, ψ2, p, q: Pattern
E: evar
i: ProofInfo
wfψ1: well_formed ψ1
wfψ2: well_formed ψ2
wfp: well_formed p
wfq: well_formed q
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]]
using i
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]]
using i
Hwf1: well_formed ψ1^[[evar:E↦p]] = true
HeqHwf1: Hwf1 =
well_formed_free_evar_subst_0 E ψ1 p wfp
  wfψ1
Hwf2: well_formed ψ1^[[evar:E↦q]] = true
HeqHwf2: Hwf2 =
well_formed_free_evar_subst_0 E ψ1 q wfq
  wfψ1
Hwf3: well_formed ψ2^[[evar:E↦p]] = true
HeqHwf3: Hwf3 =
well_formed_free_evar_subst_0 E ψ2 p wfp
  wfψ2
Hwf4: well_formed ψ2^[[evar:E↦q]] = true
HeqHwf4: Hwf4 =
well_formed_free_evar_subst_0 E ψ2 q wfq
  wfψ2
well_formed ?B
Σ: Signature
Γ: Theory
ψ1, ψ2, p, q: Pattern
E: evar
i: ProofInfo
wfψ1: well_formed ψ1
wfψ2: well_formed ψ2
wfp: well_formed p
wfq: well_formed q
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]]
using i
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]]
using i
Hwf1: well_formed ψ1^[[evar:E↦p]] = true
HeqHwf1: Hwf1 =
well_formed_free_evar_subst_0 E ψ1 p wfp
  wfψ1
Hwf2: well_formed ψ1^[[evar:E↦q]] = true
HeqHwf2: Hwf2 =
well_formed_free_evar_subst_0 E ψ1 q wfq
  wfψ1
Hwf3: well_formed ψ2^[[evar:E↦p]] = true
HeqHwf3: Hwf3 =
well_formed_free_evar_subst_0 E ψ2 p wfp
  wfψ2
Hwf4: well_formed ψ2^[[evar:E↦q]] = true
HeqHwf4: Hwf4 =
well_formed_free_evar_subst_0 E ψ2 q wfq
  wfψ2
well_formed (ψ1^[[evar:E↦q]] $ ψ2^[[evar:E↦q]])
Σ: Signature
Γ: Theory
ψ1, ψ2, p, q: Pattern
E: evar
i: ProofInfo
wfψ1: well_formed ψ1
wfψ2: well_formed ψ2
wfp: well_formed p
wfq: well_formed q
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]]
using i
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]]
using i
Hwf1: well_formed ψ1^[[evar:E↦p]] = true
HeqHwf1: Hwf1 =
well_formed_free_evar_subst_0 E ψ1 p wfp
  wfψ1
Hwf2: well_formed ψ1^[[evar:E↦q]] = true
HeqHwf2: Hwf2 =
well_formed_free_evar_subst_0 E ψ1 q wfq
  wfψ1
Hwf3: well_formed ψ2^[[evar:E↦p]] = true
HeqHwf3: Hwf3 =
well_formed_free_evar_subst_0 E ψ2 p wfp
  wfψ2
Hwf4: well_formed ψ2^[[evar:E↦q]] = true
HeqHwf4: Hwf4 =
well_formed_free_evar_subst_0 E ψ2 q wfq
  wfψ2
Γ ⊢i ψ1^[[evar:E↦p]] $ ψ2^[[evar:E↦p]] <---> ?B
using i
Σ: Signature
Γ: Theory
ψ1, ψ2, p, q: Pattern
E: evar
i: ProofInfo
wfψ1: well_formed ψ1
wfψ2: well_formed ψ2
wfp: well_formed p
wfq: well_formed q
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]]
using i
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]]
using i
Hwf1: well_formed ψ1^[[evar:E↦p]] = true
HeqHwf1: Hwf1 =
well_formed_free_evar_subst_0 E ψ1 p wfp
  wfψ1
Hwf2: well_formed ψ1^[[evar:E↦q]] = true
HeqHwf2: Hwf2 =
well_formed_free_evar_subst_0 E ψ1 q wfq
  wfψ1
Hwf3: well_formed ψ2^[[evar:E↦p]] = true
HeqHwf3: Hwf3 =
well_formed_free_evar_subst_0 E ψ2 p wfp
  wfψ2
Hwf4: well_formed ψ2^[[evar:E↦q]] = true
HeqHwf4: Hwf4 =
well_formed_free_evar_subst_0 E ψ2 q wfq
  wfψ2
Γ ⊢i ?B <---> ψ1^[[evar:E↦q]] $ ψ2^[[evar:E↦q]]
using i
    5: {
Σ: Signature
Γ: Theory
ψ1, ψ2, p, q: Pattern
E: evar
i: ProofInfo
wfψ1: well_formed ψ1
wfψ2: well_formed ψ2
wfp: well_formed p
wfq: well_formed q
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]]
using i
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]]
using i
Hwf1: well_formed ψ1^[[evar:E↦p]] = true
HeqHwf1: Hwf1 =
well_formed_free_evar_subst_0 E ψ1 p wfp
  wfψ1
Hwf2: well_formed ψ1^[[evar:E↦q]] = true
HeqHwf2: Hwf2 =
well_formed_free_evar_subst_0 E ψ1 q wfq
  wfψ1
Hwf3: well_formed ψ2^[[evar:E↦p]] = true
HeqHwf3: Hwf3 =
well_formed_free_evar_subst_0 E ψ2 p wfp
  wfψ2
Hwf4: well_formed ψ2^[[evar:E↦q]] = true
HeqHwf4: Hwf4 =
well_formed_free_evar_subst_0 E ψ2 q wfq
  wfψ2
Γ ⊢i ?B <---> ψ1^[[evar:E↦q]] $ ψ2^[[evar:E↦q]]
using i 
      apply conj_intro_meta.
Σ: Signature
Γ: Theory
ψ1, ψ2, p, q: Pattern
E: evar
i: ProofInfo
wfψ1: well_formed ψ1
wfψ2: well_formed ψ2
wfp: well_formed p
wfq: well_formed q
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]]
using i
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]]
using i
Hwf1: well_formed ψ1^[[evar:E↦p]] = true
HeqHwf1: Hwf1 =
well_formed_free_evar_subst_0 E ψ1 p wfp
  wfψ1
Hwf2: well_formed ψ1^[[evar:E↦q]] = true
HeqHwf2: Hwf2 =
well_formed_free_evar_subst_0 E ψ1 q wfq
  wfψ1
Hwf3: well_formed ψ2^[[evar:E↦p]] = true
HeqHwf3: Hwf3 =
well_formed_free_evar_subst_0 E ψ2 p wfp
  wfψ2
Hwf4: well_formed ψ2^[[evar:E↦q]] = true
HeqHwf4: Hwf4 =
well_formed_free_evar_subst_0 E ψ2 q wfq
  wfψ2
well_formed
  (?B ---> ψ1^[[evar:E↦q]] $ ψ2^[[evar:E↦q]])
Σ: Signature
Γ: Theory
ψ1, ψ2, p, q: Pattern
E: evar
i: ProofInfo
wfψ1: well_formed ψ1
wfψ2: well_formed ψ2
wfp: well_formed p
wfq: well_formed q
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]]
using i
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]]
using i
Hwf1: well_formed ψ1^[[evar:E↦p]] = true
HeqHwf1: Hwf1 =
well_formed_free_evar_subst_0 E ψ1 p wfp
  wfψ1
Hwf2: well_formed ψ1^[[evar:E↦q]] = true
HeqHwf2: Hwf2 =
well_formed_free_evar_subst_0 E ψ1 q wfq
  wfψ1
Hwf3: well_formed ψ2^[[evar:E↦p]] = true
HeqHwf3: Hwf3 =
well_formed_free_evar_subst_0 E ψ2 p wfp
  wfψ2
Hwf4: well_formed ψ2^[[evar:E↦q]] = true
HeqHwf4: Hwf4 =
well_formed_free_evar_subst_0 E ψ2 q wfq
  wfψ2
well_formed
  (ψ1^[[evar:E↦q]] $ ψ2^[[evar:E↦q]] ---> ?B)
Σ: Signature
Γ: Theory
ψ1, ψ2, p, q: Pattern
E: evar
i: ProofInfo
wfψ1: well_formed ψ1
wfψ2: well_formed ψ2
wfp: well_formed p
wfq: well_formed q
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]]
using i
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]]
using i
Hwf1: well_formed ψ1^[[evar:E↦p]] = true
HeqHwf1: Hwf1 =
well_formed_free_evar_subst_0 E ψ1 p wfp
  wfψ1
Hwf2: well_formed ψ1^[[evar:E↦q]] = true
HeqHwf2: Hwf2 =
well_formed_free_evar_subst_0 E ψ1 q wfq
  wfψ1
Hwf3: well_formed ψ2^[[evar:E↦p]] = true
HeqHwf3: Hwf3 =
well_formed_free_evar_subst_0 E ψ2 p wfp
  wfψ2
Hwf4: well_formed ψ2^[[evar:E↦q]] = true
HeqHwf4: Hwf4 =
well_formed_free_evar_subst_0 E ψ2 q wfq
  wfψ2
Γ ⊢i ?B ---> ψ1^[[evar:E↦q]] $ ψ2^[[evar:E↦q]] using i
Σ: Signature
Γ: Theory
ψ1, ψ2, p, q: Pattern
E: evar
i: ProofInfo
wfψ1: well_formed ψ1
wfψ2: well_formed ψ2
wfp: well_formed p
wfq: well_formed q
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]]
using i
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]]
using i
Hwf1: well_formed ψ1^[[evar:E↦p]] = true
HeqHwf1: Hwf1 =
well_formed_free_evar_subst_0 E ψ1 p wfp
  wfψ1
Hwf2: well_formed ψ1^[[evar:E↦q]] = true
HeqHwf2: Hwf2 =
well_formed_free_evar_subst_0 E ψ1 q wfq
  wfψ1
Hwf3: well_formed ψ2^[[evar:E↦p]] = true
HeqHwf3: Hwf3 =
well_formed_free_evar_subst_0 E ψ2 p wfp
  wfψ2
Hwf4: well_formed ψ2^[[evar:E↦q]] = true
HeqHwf4: Hwf4 =
well_formed_free_evar_subst_0 E ψ2 q wfq
  wfψ2
Γ ⊢i ψ1^[[evar:E↦q]] $ ψ2^[[evar:E↦q]] ---> ?B using i
      4: {
Σ: Signature
Γ: Theory
ψ1, ψ2, p, q: Pattern
E: evar
i: ProofInfo
wfψ1: well_formed ψ1
wfψ2: well_formed ψ2
wfp: well_formed p
wfq: well_formed q
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]]
using i
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]]
using i
Hwf1: well_formed ψ1^[[evar:E↦p]] = true
HeqHwf1: Hwf1 =
well_formed_free_evar_subst_0 E ψ1 p wfp
  wfψ1
Hwf2: well_formed ψ1^[[evar:E↦q]] = true
HeqHwf2: Hwf2 =
well_formed_free_evar_subst_0 E ψ1 q wfq
  wfψ1
Hwf3: well_formed ψ2^[[evar:E↦p]] = true
HeqHwf3: Hwf3 =
well_formed_free_evar_subst_0 E ψ2 p wfp
  wfψ2
Hwf4: well_formed ψ2^[[evar:E↦q]] = true
HeqHwf4: Hwf4 =
well_formed_free_evar_subst_0 E ψ2 q wfq
  wfψ2
Γ ⊢i ψ1^[[evar:E↦q]] $ ψ2^[[evar:E↦q]] ---> ?B using i
        eapply Framing_right with (ψ := ψ1^[[evar: E ↦ q]]); auto.
Σ: Signature
Γ: Theory
ψ1, ψ2, p, q: Pattern
E: evar
i: ProofInfo
wfψ1: well_formed ψ1
wfψ2: well_formed ψ2
wfp: well_formed p
wfq: well_formed q
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]]
using i
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]]
using i
Hwf1: well_formed ψ1^[[evar:E↦p]] = true
HeqHwf1: Hwf1 =
well_formed_free_evar_subst_0 E ψ1 p wfp
  wfψ1
Hwf2: well_formed ψ1^[[evar:E↦q]] = true
HeqHwf2: Hwf2 =
well_formed_free_evar_subst_0 E ψ1 q wfq
  wfψ1
Hwf3: well_formed ψ2^[[evar:E↦p]] = true
HeqHwf3: Hwf3 =
well_formed_free_evar_subst_0 E ψ2 p wfp
  wfψ2
Hwf4: well_formed ψ2^[[evar:E↦q]] = true
HeqHwf4: Hwf4 =
well_formed_free_evar_subst_0 E ψ2 q wfq
  wfψ2
ProofInfoLe (ExGen := ∅, SVSubst := ∅, KT := false) i
Σ: Signature
Γ: Theory
ψ1, ψ2, p, q: Pattern
E: evar
i: ProofInfo
wfψ1: well_formed ψ1
wfψ2: well_formed ψ2
wfp: well_formed p
wfq: well_formed q
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]]
using i
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]]
using i
Hwf1: well_formed ψ1^[[evar:E↦p]] = true
HeqHwf1: Hwf1 =
well_formed_free_evar_subst_0 E ψ1 p wfp
  wfψ1
Hwf2: well_formed ψ1^[[evar:E↦q]] = true
HeqHwf2: Hwf2 =
well_formed_free_evar_subst_0 E ψ1 q wfq
  wfψ1
Hwf3: well_formed ψ2^[[evar:E↦p]] = true
HeqHwf3: Hwf3 =
well_formed_free_evar_subst_0 E ψ2 p wfp
  wfψ2
Hwf4: well_formed ψ2^[[evar:E↦q]] = true
HeqHwf4: Hwf4 =
well_formed_free_evar_subst_0 E ψ2 q wfq
  wfψ2
Γ ⊢i ψ2^[[evar:E↦q]] ---> ?ϕ₂ using i
        1: {
Σ: Signature
Γ: Theory
ψ1, ψ2, p, q: Pattern
E: evar
i: ProofInfo
wfψ1: well_formed ψ1
wfψ2: well_formed ψ2
wfp: well_formed p
wfq: well_formed q
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]]
using i
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]]
using i
Hwf1: well_formed ψ1^[[evar:E↦p]] = true
HeqHwf1: Hwf1 =
well_formed_free_evar_subst_0 E ψ1 p wfp
  wfψ1
Hwf2: well_formed ψ1^[[evar:E↦q]] = true
HeqHwf2: Hwf2 =
well_formed_free_evar_subst_0 E ψ1 q wfq
  wfψ1
Hwf3: well_formed ψ2^[[evar:E↦p]] = true
HeqHwf3: Hwf3 =
well_formed_free_evar_subst_0 E ψ2 p wfp
  wfψ2
Hwf4: well_formed ψ2^[[evar:E↦q]] = true
HeqHwf4: Hwf4 =
well_formed_free_evar_subst_0 E ψ2 q wfq
  wfψ2
ProofInfoLe (ExGen := ∅, SVSubst := ∅, KT := false) i try_solve_pile. }
Σ: Signature
Γ: Theory
ψ1, ψ2, p, q: Pattern
E: evar
i: ProofInfo
wfψ1: well_formed ψ1
wfψ2: well_formed ψ2
wfp: well_formed p
wfq: well_formed q
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]]
using i
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]]
using i
Hwf1: well_formed ψ1^[[evar:E↦p]] = true
HeqHwf1: Hwf1 =
well_formed_free_evar_subst_0 E ψ1 p wfp
  wfψ1
Hwf2: well_formed ψ1^[[evar:E↦q]] = true
HeqHwf2: Hwf2 =
well_formed_free_evar_subst_0 E ψ1 q wfq
  wfψ1
Hwf3: well_formed ψ2^[[evar:E↦p]] = true
HeqHwf3: Hwf3 =
well_formed_free_evar_subst_0 E ψ2 p wfp
  wfψ2
Hwf4: well_formed ψ2^[[evar:E↦q]] = true
HeqHwf4: Hwf4 =
well_formed_free_evar_subst_0 E ψ2 q wfq
  wfψ2
Γ ⊢i ψ2^[[evar:E↦q]] ---> ?ϕ₂ using i
        {
Σ: Signature
Γ: Theory
ψ1, ψ2, p, q: Pattern
E: evar
i: ProofInfo
wfψ1: well_formed ψ1
wfψ2: well_formed ψ2
wfp: well_formed p
wfq: well_formed q
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]]
using i
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]]
using i
Hwf1: well_formed ψ1^[[evar:E↦p]] = true
HeqHwf1: Hwf1 =
well_formed_free_evar_subst_0 E ψ1 p wfp
  wfψ1
Hwf2: well_formed ψ1^[[evar:E↦q]] = true
HeqHwf2: Hwf2 =
well_formed_free_evar_subst_0 E ψ1 q wfq
  wfψ1
Hwf3: well_formed ψ2^[[evar:E↦p]] = true
HeqHwf3: Hwf3 =
well_formed_free_evar_subst_0 E ψ2 p wfp
  wfψ2
Hwf4: well_formed ψ2^[[evar:E↦q]] = true
HeqHwf4: Hwf4 =
well_formed_free_evar_subst_0 E ψ2 q wfq
  wfψ2
Γ ⊢i ψ2^[[evar:E↦q]] ---> ?ϕ₂ using i
          eapply pf_conj_elim_r_meta in pf₂.
Σ: Signature
Γ: Theory
ψ1, ψ2, p, q: Pattern
E: evar
i: ProofInfo
wfψ1: well_formed ψ1
wfψ2: well_formed ψ2
wfp: well_formed p
wfq: well_formed q
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]]
using i
pf₂: Γ ⊢i ψ2^[[evar:E↦q]] ---> ψ2^[[evar:E↦p]]
using i
Hwf1: well_formed ψ1^[[evar:E↦p]] = true
HeqHwf1: Hwf1 =
well_formed_free_evar_subst_0 E ψ1 p wfp
  wfψ1
Hwf2: well_formed ψ1^[[evar:E↦q]] = true
HeqHwf2: Hwf2 =
well_formed_free_evar_subst_0 E ψ1 q wfq
  wfψ1
Hwf3: well_formed ψ2^[[evar:E↦p]] = true
HeqHwf3: Hwf3 =
well_formed_free_evar_subst_0 E ψ2 p wfp
  wfψ2
Hwf4: well_formed ψ2^[[evar:E↦q]] = true
HeqHwf4: Hwf4 =
well_formed_free_evar_subst_0 E ψ2 q wfq
  wfψ2
Γ ⊢i ψ2^[[evar:E↦q]] ---> ?ϕ₂ using i
Σ: Signature
Γ: Theory
ψ1, ψ2, p, q: Pattern
E: evar
i: ProofInfo
wfψ1: well_formed ψ1
wfψ2: well_formed ψ2
wfp: well_formed p
wfq: well_formed q
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]]
using i
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]]
using i
Hwf1: well_formed ψ1^[[evar:E↦p]] = true
HeqHwf1: Hwf1 =
well_formed_free_evar_subst_0 E ψ1 p wfp
  wfψ1
Hwf2: well_formed ψ1^[[evar:E↦q]] = true
HeqHwf2: Hwf2 =
well_formed_free_evar_subst_0 E ψ1 q wfq
  wfψ1
Hwf3: well_formed ψ2^[[evar:E↦p]] = true
HeqHwf3: Hwf3 =
well_formed_free_evar_subst_0 E ψ2 p wfp
  wfψ2
Hwf4: well_formed ψ2^[[evar:E↦q]] = true
HeqHwf4: Hwf4 =
well_formed_free_evar_subst_0 E ψ2 q wfq
  wfψ2
well_formed (ψ2^[[evar:E↦p]] ---> ψ2^[[evar:E↦q]])
Σ: Signature
Γ: Theory
ψ1, ψ2, p, q: Pattern
E: evar
i: ProofInfo
wfψ1: well_formed ψ1
wfψ2: well_formed ψ2
wfp: well_formed p
wfq: well_formed q
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]]
using i
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]]
using i
Hwf1: well_formed ψ1^[[evar:E↦p]] = true
HeqHwf1: Hwf1 =
well_formed_free_evar_subst_0 E ψ1 p wfp
  wfψ1
Hwf2: well_formed ψ1^[[evar:E↦q]] = true
HeqHwf2: Hwf2 =
well_formed_free_evar_subst_0 E ψ1 q wfq
  wfψ1
Hwf3: well_formed ψ2^[[evar:E↦p]] = true
HeqHwf3: Hwf3 =
well_formed_free_evar_subst_0 E ψ2 p wfp
  wfψ2
Hwf4: well_formed ψ2^[[evar:E↦q]] = true
HeqHwf4: Hwf4 =
well_formed_free_evar_subst_0 E ψ2 q wfq
  wfψ2
well_formed (ψ2^[[evar:E↦q]] ---> ψ2^[[evar:E↦p]])
          apply pf₂.
Σ: Signature
Γ: Theory
ψ1, ψ2, p, q: Pattern
E: evar
i: ProofInfo
wfψ1: well_formed ψ1
wfψ2: well_formed ψ2
wfp: well_formed p
wfq: well_formed q
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]]
using i
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]]
using i
Hwf1: well_formed ψ1^[[evar:E↦p]] = true
HeqHwf1: Hwf1 =
well_formed_free_evar_subst_0 E ψ1 p wfp
  wfψ1
Hwf2: well_formed ψ1^[[evar:E↦q]] = true
HeqHwf2: Hwf2 =
well_formed_free_evar_subst_0 E ψ1 q wfq
  wfψ1
Hwf3: well_formed ψ2^[[evar:E↦p]] = true
HeqHwf3: Hwf3 =
well_formed_free_evar_subst_0 E ψ2 p wfp
  wfψ2
Hwf4: well_formed ψ2^[[evar:E↦q]] = true
HeqHwf4: Hwf4 =
well_formed_free_evar_subst_0 E ψ2 q wfq
  wfψ2
well_formed (ψ2^[[evar:E↦p]] ---> ψ2^[[evar:E↦q]])
Σ: Signature
Γ: Theory
ψ1, ψ2, p, q: Pattern
E: evar
i: ProofInfo
wfψ1: well_formed ψ1
wfψ2: well_formed ψ2
wfp: well_formed p
wfq: well_formed q
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]]
using i
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]]
using i
Hwf1: well_formed ψ1^[[evar:E↦p]] = true
HeqHwf1: Hwf1 =
well_formed_free_evar_subst_0 E ψ1 p wfp
  wfψ1
Hwf2: well_formed ψ1^[[evar:E↦q]] = true
HeqHwf2: Hwf2 =
well_formed_free_evar_subst_0 E ψ1 q wfq
  wfψ1
Hwf3: well_formed ψ2^[[evar:E↦p]] = true
HeqHwf3: Hwf3 =
well_formed_free_evar_subst_0 E ψ2 p wfp
  wfψ2
Hwf4: well_formed ψ2^[[evar:E↦q]] = true
HeqHwf4: Hwf4 =
well_formed_free_evar_subst_0 E ψ2 q wfq
  wfψ2
well_formed (ψ2^[[evar:E↦q]] ---> ψ2^[[evar:E↦p]])
          {
Σ: Signature
Γ: Theory
ψ1, ψ2, p, q: Pattern
E: evar
i: ProofInfo
wfψ1: well_formed ψ1
wfψ2: well_formed ψ2
wfp: well_formed p
wfq: well_formed q
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]]
using i
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]]
using i
Hwf1: well_formed ψ1^[[evar:E↦p]] = true
HeqHwf1: Hwf1 =
well_formed_free_evar_subst_0 E ψ1 p wfp
  wfψ1
Hwf2: well_formed ψ1^[[evar:E↦q]] = true
HeqHwf2: Hwf2 =
well_formed_free_evar_subst_0 E ψ1 q wfq
  wfψ1
Hwf3: well_formed ψ2^[[evar:E↦p]] = true
HeqHwf3: Hwf3 =
well_formed_free_evar_subst_0 E ψ2 p wfp
  wfψ2
Hwf4: well_formed ψ2^[[evar:E↦q]] = true
HeqHwf4: Hwf4 =
well_formed_free_evar_subst_0 E ψ2 q wfq
  wfψ2
well_formed (ψ2^[[evar:E↦p]] ---> ψ2^[[evar:E↦q]]) abstract (wf_auto2). }
Σ: Signature
Γ: Theory
ψ1, ψ2, p, q: Pattern
E: evar
i: ProofInfo
wfψ1: well_formed ψ1
wfψ2: well_formed ψ2
wfp: well_formed p
wfq: well_formed q
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]]
using i
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]]
using i
Hwf1: well_formed ψ1^[[evar:E↦p]] = true
HeqHwf1: Hwf1 =
well_formed_free_evar_subst_0 E ψ1 p wfp
  wfψ1
Hwf2: well_formed ψ1^[[evar:E↦q]] = true
HeqHwf2: Hwf2 =
well_formed_free_evar_subst_0 E ψ1 q wfq
  wfψ1
Hwf3: well_formed ψ2^[[evar:E↦p]] = true
HeqHwf3: Hwf3 =
well_formed_free_evar_subst_0 E ψ2 p wfp
  wfψ2
Hwf4: well_formed ψ2^[[evar:E↦q]] = true
HeqHwf4: Hwf4 =
well_formed_free_evar_subst_0 E ψ2 q wfq
  wfψ2
well_formed (ψ2^[[evar:E↦q]] ---> ψ2^[[evar:E↦p]])
          {
Σ: Signature
Γ: Theory
ψ1, ψ2, p, q: Pattern
E: evar
i: ProofInfo
wfψ1: well_formed ψ1
wfψ2: well_formed ψ2
wfp: well_formed p
wfq: well_formed q
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]]
using i
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]]
using i
Hwf1: well_formed ψ1^[[evar:E↦p]] = true
HeqHwf1: Hwf1 =
well_formed_free_evar_subst_0 E ψ1 p wfp
  wfψ1
Hwf2: well_formed ψ1^[[evar:E↦q]] = true
HeqHwf2: Hwf2 =
well_formed_free_evar_subst_0 E ψ1 q wfq
  wfψ1
Hwf3: well_formed ψ2^[[evar:E↦p]] = true
HeqHwf3: Hwf3 =
well_formed_free_evar_subst_0 E ψ2 p wfp
  wfψ2
Hwf4: well_formed ψ2^[[evar:E↦q]] = true
HeqHwf4: Hwf4 =
well_formed_free_evar_subst_0 E ψ2 q wfq
  wfψ2
well_formed (ψ2^[[evar:E↦q]] ---> ψ2^[[evar:E↦p]]) abstract (wf_auto2). }
        }
      }
Σ: Signature
Γ: Theory
ψ1, ψ2, p, q: Pattern
E: evar
i: ProofInfo
wfψ1: well_formed ψ1
wfψ2: well_formed ψ2
wfp: well_formed p
wfq: well_formed q
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]]
using i
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]]
using i
Hwf1: well_formed ψ1^[[evar:E↦p]] = true
HeqHwf1: Hwf1 =
well_formed_free_evar_subst_0 E ψ1 p wfp
  wfψ1
Hwf2: well_formed ψ1^[[evar:E↦q]] = true
HeqHwf2: Hwf2 =
well_formed_free_evar_subst_0 E ψ1 q wfq
  wfψ1
Hwf3: well_formed ψ2^[[evar:E↦p]] = true
HeqHwf3: Hwf3 =
well_formed_free_evar_subst_0 E ψ2 p wfp
  wfψ2
Hwf4: well_formed ψ2^[[evar:E↦q]] = true
HeqHwf4: Hwf4 =
well_formed_free_evar_subst_0 E ψ2 q wfq
  wfψ2
well_formed
  (ψ1^[[evar:E↦q]] $ ψ2^[[evar:E↦p]] --->
   ψ1^[[evar:E↦q]] $ ψ2^[[evar:E↦q]])
Σ: Signature
Γ: Theory
ψ1, ψ2, p, q: Pattern
E: evar
i: ProofInfo
wfψ1: well_formed ψ1
wfψ2: well_formed ψ2
wfp: well_formed p
wfq: well_formed q
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]]
using i
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]]
using i
Hwf1: well_formed ψ1^[[evar:E↦p]] = true
HeqHwf1: Hwf1 =
well_formed_free_evar_subst_0 E ψ1 p wfp
  wfψ1
Hwf2: well_formed ψ1^[[evar:E↦q]] = true
HeqHwf2: Hwf2 =
well_formed_free_evar_subst_0 E ψ1 q wfq
  wfψ1
Hwf3: well_formed ψ2^[[evar:E↦p]] = true
HeqHwf3: Hwf3 =
well_formed_free_evar_subst_0 E ψ2 p wfp
  wfψ2
Hwf4: well_formed ψ2^[[evar:E↦q]] = true
HeqHwf4: Hwf4 =
well_formed_free_evar_subst_0 E ψ2 q wfq
  wfψ2
well_formed
  (ψ1^[[evar:E↦q]] $ ψ2^[[evar:E↦q]] --->
   ψ1^[[evar:E↦q]] $ ψ2^[[evar:E↦p]])
Σ: Signature
Γ: Theory
ψ1, ψ2, p, q: Pattern
E: evar
i: ProofInfo
wfψ1: well_formed ψ1
wfψ2: well_formed ψ2
wfp: well_formed p
wfq: well_formed q
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]]
using i
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]]
using i
Hwf1: well_formed ψ1^[[evar:E↦p]] = true
HeqHwf1: Hwf1 =
well_formed_free_evar_subst_0 E ψ1 p wfp
  wfψ1
Hwf2: well_formed ψ1^[[evar:E↦q]] = true
HeqHwf2: Hwf2 =
well_formed_free_evar_subst_0 E ψ1 q wfq
  wfψ1
Hwf3: well_formed ψ2^[[evar:E↦p]] = true
HeqHwf3: Hwf3 =
well_formed_free_evar_subst_0 E ψ2 p wfp
  wfψ2
Hwf4: well_formed ψ2^[[evar:E↦q]] = true
HeqHwf4: Hwf4 =
well_formed_free_evar_subst_0 E ψ2 q wfq
  wfψ2
Γ
⊢i ψ1^[[evar:E↦q]] $ ψ2^[[evar:E↦p]] --->
   ψ1^[[evar:E↦q]] $ ψ2^[[evar:E↦q]] using i
      3: {
Σ: Signature
Γ: Theory
ψ1, ψ2, p, q: Pattern
E: evar
i: ProofInfo
wfψ1: well_formed ψ1
wfψ2: well_formed ψ2
wfp: well_formed p
wfq: well_formed q
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]]
using i
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]]
using i
Hwf1: well_formed ψ1^[[evar:E↦p]] = true
HeqHwf1: Hwf1 =
well_formed_free_evar_subst_0 E ψ1 p wfp
  wfψ1
Hwf2: well_formed ψ1^[[evar:E↦q]] = true
HeqHwf2: Hwf2 =
well_formed_free_evar_subst_0 E ψ1 q wfq
  wfψ1
Hwf3: well_formed ψ2^[[evar:E↦p]] = true
HeqHwf3: Hwf3 =
well_formed_free_evar_subst_0 E ψ2 p wfp
  wfψ2
Hwf4: well_formed ψ2^[[evar:E↦q]] = true
HeqHwf4: Hwf4 =
well_formed_free_evar_subst_0 E ψ2 q wfq
  wfψ2
Γ
⊢i ψ1^[[evar:E↦q]] $ ψ2^[[evar:E↦p]] --->
   ψ1^[[evar:E↦q]] $ ψ2^[[evar:E↦q]] using i
        eapply Framing_right with (ψ := ψ1^[[evar: E ↦ q]]); auto.
Σ: Signature
Γ: Theory
ψ1, ψ2, p, q: Pattern
E: evar
i: ProofInfo
wfψ1: well_formed ψ1
wfψ2: well_formed ψ2
wfp: well_formed p
wfq: well_formed q
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]]
using i
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]]
using i
Hwf1: well_formed ψ1^[[evar:E↦p]] = true
HeqHwf1: Hwf1 =
well_formed_free_evar_subst_0 E ψ1 p wfp
  wfψ1
Hwf2: well_formed ψ1^[[evar:E↦q]] = true
HeqHwf2: Hwf2 =
well_formed_free_evar_subst_0 E ψ1 q wfq
  wfψ1
Hwf3: well_formed ψ2^[[evar:E↦p]] = true
HeqHwf3: Hwf3 =
well_formed_free_evar_subst_0 E ψ2 p wfp
  wfψ2
Hwf4: well_formed ψ2^[[evar:E↦q]] = true
HeqHwf4: Hwf4 =
well_formed_free_evar_subst_0 E ψ2 q wfq
  wfψ2
ProofInfoLe (ExGen := ∅, SVSubst := ∅, KT := false) i
Σ: Signature
Γ: Theory
ψ1, ψ2, p, q: Pattern
E: evar
i: ProofInfo
wfψ1: well_formed ψ1
wfψ2: well_formed ψ2
wfp: well_formed p
wfq: well_formed q
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]]
using i
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]]
using i
Hwf1: well_formed ψ1^[[evar:E↦p]] = true
HeqHwf1: Hwf1 =
well_formed_free_evar_subst_0 E ψ1 p wfp
  wfψ1
Hwf2: well_formed ψ1^[[evar:E↦q]] = true
HeqHwf2: Hwf2 =
well_formed_free_evar_subst_0 E ψ1 q wfq
  wfψ1
Hwf3: well_formed ψ2^[[evar:E↦p]] = true
HeqHwf3: Hwf3 =
well_formed_free_evar_subst_0 E ψ2 p wfp
  wfψ2
Hwf4: well_formed ψ2^[[evar:E↦q]] = true
HeqHwf4: Hwf4 =
well_formed_free_evar_subst_0 E ψ2 q wfq
  wfψ2
Γ ⊢i ψ2^[[evar:E↦p]] ---> ψ2^[[evar:E↦q]] using i
        1: {
Σ: Signature
Γ: Theory
ψ1, ψ2, p, q: Pattern
E: evar
i: ProofInfo
wfψ1: well_formed ψ1
wfψ2: well_formed ψ2
wfp: well_formed p
wfq: well_formed q
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]]
using i
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]]
using i
Hwf1: well_formed ψ1^[[evar:E↦p]] = true
HeqHwf1: Hwf1 =
well_formed_free_evar_subst_0 E ψ1 p wfp
  wfψ1
Hwf2: well_formed ψ1^[[evar:E↦q]] = true
HeqHwf2: Hwf2 =
well_formed_free_evar_subst_0 E ψ1 q wfq
  wfψ1
Hwf3: well_formed ψ2^[[evar:E↦p]] = true
HeqHwf3: Hwf3 =
well_formed_free_evar_subst_0 E ψ2 p wfp
  wfψ2
Hwf4: well_formed ψ2^[[evar:E↦q]] = true
HeqHwf4: Hwf4 =
well_formed_free_evar_subst_0 E ψ2 q wfq
  wfψ2
ProofInfoLe (ExGen := ∅, SVSubst := ∅, KT := false) i try_solve_pile. }
Σ: Signature
Γ: Theory
ψ1, ψ2, p, q: Pattern
E: evar
i: ProofInfo
wfψ1: well_formed ψ1
wfψ2: well_formed ψ2
wfp: well_formed p
wfq: well_formed q
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]]
using i
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]]
using i
Hwf1: well_formed ψ1^[[evar:E↦p]] = true
HeqHwf1: Hwf1 =
well_formed_free_evar_subst_0 E ψ1 p wfp
  wfψ1
Hwf2: well_formed ψ1^[[evar:E↦q]] = true
HeqHwf2: Hwf2 =
well_formed_free_evar_subst_0 E ψ1 q wfq
  wfψ1
Hwf3: well_formed ψ2^[[evar:E↦p]] = true
HeqHwf3: Hwf3 =
well_formed_free_evar_subst_0 E ψ2 p wfp
  wfψ2
Hwf4: well_formed ψ2^[[evar:E↦q]] = true
HeqHwf4: Hwf4 =
well_formed_free_evar_subst_0 E ψ2 q wfq
  wfψ2
Γ ⊢i ψ2^[[evar:E↦p]] ---> ψ2^[[evar:E↦q]] using i
        {
Σ: Signature
Γ: Theory
ψ1, ψ2, p, q: Pattern
E: evar
i: ProofInfo
wfψ1: well_formed ψ1
wfψ2: well_formed ψ2
wfp: well_formed p
wfq: well_formed q
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]]
using i
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]]
using i
Hwf1: well_formed ψ1^[[evar:E↦p]] = true
HeqHwf1: Hwf1 =
well_formed_free_evar_subst_0 E ψ1 p wfp
  wfψ1
Hwf2: well_formed ψ1^[[evar:E↦q]] = true
HeqHwf2: Hwf2 =
well_formed_free_evar_subst_0 E ψ1 q wfq
  wfψ1
Hwf3: well_formed ψ2^[[evar:E↦p]] = true
HeqHwf3: Hwf3 =
well_formed_free_evar_subst_0 E ψ2 p wfp
  wfψ2
Hwf4: well_formed ψ2^[[evar:E↦q]] = true
HeqHwf4: Hwf4 =
well_formed_free_evar_subst_0 E ψ2 q wfq
  wfψ2
Γ ⊢i ψ2^[[evar:E↦p]] ---> ψ2^[[evar:E↦q]] using i
          eapply pf_conj_elim_l_meta in pf₂.
Σ: Signature
Γ: Theory
ψ1, ψ2, p, q: Pattern
E: evar
i: ProofInfo
wfψ1: well_formed ψ1
wfψ2: well_formed ψ2
wfp: well_formed p
wfq: well_formed q
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]]
using i
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] ---> ψ2^[[evar:E↦q]]
using i
Hwf1: well_formed ψ1^[[evar:E↦p]] = true
HeqHwf1: Hwf1 =
well_formed_free_evar_subst_0 E ψ1 p wfp
  wfψ1
Hwf2: well_formed ψ1^[[evar:E↦q]] = true
HeqHwf2: Hwf2 =
well_formed_free_evar_subst_0 E ψ1 q wfq
  wfψ1
Hwf3: well_formed ψ2^[[evar:E↦p]] = true
HeqHwf3: Hwf3 =
well_formed_free_evar_subst_0 E ψ2 p wfp
  wfψ2
Hwf4: well_formed ψ2^[[evar:E↦q]] = true
HeqHwf4: Hwf4 =
well_formed_free_evar_subst_0 E ψ2 q wfq
  wfψ2
Γ ⊢i ψ2^[[evar:E↦p]] ---> ψ2^[[evar:E↦q]] using i
Σ: Signature
Γ: Theory
ψ1, ψ2, p, q: Pattern
E: evar
i: ProofInfo
wfψ1: well_formed ψ1
wfψ2: well_formed ψ2
wfp: well_formed p
wfq: well_formed q
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]]
using i
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]]
using i
Hwf1: well_formed ψ1^[[evar:E↦p]] = true
HeqHwf1: Hwf1 =
well_formed_free_evar_subst_0 E ψ1 p wfp
  wfψ1
Hwf2: well_formed ψ1^[[evar:E↦q]] = true
HeqHwf2: Hwf2 =
well_formed_free_evar_subst_0 E ψ1 q wfq
  wfψ1
Hwf3: well_formed ψ2^[[evar:E↦p]] = true
HeqHwf3: Hwf3 =
well_formed_free_evar_subst_0 E ψ2 p wfp
  wfψ2
Hwf4: well_formed ψ2^[[evar:E↦q]] = true
HeqHwf4: Hwf4 =
well_formed_free_evar_subst_0 E ψ2 q wfq
  wfψ2
well_formed (ψ2^[[evar:E↦p]] ---> ψ2^[[evar:E↦q]])
Σ: Signature
Γ: Theory
ψ1, ψ2, p, q: Pattern
E: evar
i: ProofInfo
wfψ1: well_formed ψ1
wfψ2: well_formed ψ2
wfp: well_formed p
wfq: well_formed q
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]]
using i
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]]
using i
Hwf1: well_formed ψ1^[[evar:E↦p]] = true
HeqHwf1: Hwf1 =
well_formed_free_evar_subst_0 E ψ1 p wfp
  wfψ1
Hwf2: well_formed ψ1^[[evar:E↦q]] = true
HeqHwf2: Hwf2 =
well_formed_free_evar_subst_0 E ψ1 q wfq
  wfψ1
Hwf3: well_formed ψ2^[[evar:E↦p]] = true
HeqHwf3: Hwf3 =
well_formed_free_evar_subst_0 E ψ2 p wfp
  wfψ2
Hwf4: well_formed ψ2^[[evar:E↦q]] = true
HeqHwf4: Hwf4 =
well_formed_free_evar_subst_0 E ψ2 q wfq
  wfψ2
well_formed (ψ2^[[evar:E↦q]] ---> ψ2^[[evar:E↦p]])
          apply pf₂.
Σ: Signature
Γ: Theory
ψ1, ψ2, p, q: Pattern
E: evar
i: ProofInfo
wfψ1: well_formed ψ1
wfψ2: well_formed ψ2
wfp: well_formed p
wfq: well_formed q
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]]
using i
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]]
using i
Hwf1: well_formed ψ1^[[evar:E↦p]] = true
HeqHwf1: Hwf1 =
well_formed_free_evar_subst_0 E ψ1 p wfp
  wfψ1
Hwf2: well_formed ψ1^[[evar:E↦q]] = true
HeqHwf2: Hwf2 =
well_formed_free_evar_subst_0 E ψ1 q wfq
  wfψ1
Hwf3: well_formed ψ2^[[evar:E↦p]] = true
HeqHwf3: Hwf3 =
well_formed_free_evar_subst_0 E ψ2 p wfp
  wfψ2
Hwf4: well_formed ψ2^[[evar:E↦q]] = true
HeqHwf4: Hwf4 =
well_formed_free_evar_subst_0 E ψ2 q wfq
  wfψ2
well_formed (ψ2^[[evar:E↦p]] ---> ψ2^[[evar:E↦q]])
Σ: Signature
Γ: Theory
ψ1, ψ2, p, q: Pattern
E: evar
i: ProofInfo
wfψ1: well_formed ψ1
wfψ2: well_formed ψ2
wfp: well_formed p
wfq: well_formed q
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]]
using i
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]]
using i
Hwf1: well_formed ψ1^[[evar:E↦p]] = true
HeqHwf1: Hwf1 =
well_formed_free_evar_subst_0 E ψ1 p wfp
  wfψ1
Hwf2: well_formed ψ1^[[evar:E↦q]] = true
HeqHwf2: Hwf2 =
well_formed_free_evar_subst_0 E ψ1 q wfq
  wfψ1
Hwf3: well_formed ψ2^[[evar:E↦p]] = true
HeqHwf3: Hwf3 =
well_formed_free_evar_subst_0 E ψ2 p wfp
  wfψ2
Hwf4: well_formed ψ2^[[evar:E↦q]] = true
HeqHwf4: Hwf4 =
well_formed_free_evar_subst_0 E ψ2 q wfq
  wfψ2
well_formed (ψ2^[[evar:E↦q]] ---> ψ2^[[evar:E↦p]])
          {
Σ: Signature
Γ: Theory
ψ1, ψ2, p, q: Pattern
E: evar
i: ProofInfo
wfψ1: well_formed ψ1
wfψ2: well_formed ψ2
wfp: well_formed p
wfq: well_formed q
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]]
using i
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]]
using i
Hwf1: well_formed ψ1^[[evar:E↦p]] = true
HeqHwf1: Hwf1 =
well_formed_free_evar_subst_0 E ψ1 p wfp
  wfψ1
Hwf2: well_formed ψ1^[[evar:E↦q]] = true
HeqHwf2: Hwf2 =
well_formed_free_evar_subst_0 E ψ1 q wfq
  wfψ1
Hwf3: well_formed ψ2^[[evar:E↦p]] = true
HeqHwf3: Hwf3 =
well_formed_free_evar_subst_0 E ψ2 p wfp
  wfψ2
Hwf4: well_formed ψ2^[[evar:E↦q]] = true
HeqHwf4: Hwf4 =
well_formed_free_evar_subst_0 E ψ2 q wfq
  wfψ2
well_formed (ψ2^[[evar:E↦p]] ---> ψ2^[[evar:E↦q]]) abstract (wf_auto2). }
Σ: Signature
Γ: Theory
ψ1, ψ2, p, q: Pattern
E: evar
i: ProofInfo
wfψ1: well_formed ψ1
wfψ2: well_formed ψ2
wfp: well_formed p
wfq: well_formed q
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]]
using i
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]]
using i
Hwf1: well_formed ψ1^[[evar:E↦p]] = true
HeqHwf1: Hwf1 =
well_formed_free_evar_subst_0 E ψ1 p wfp
  wfψ1
Hwf2: well_formed ψ1^[[evar:E↦q]] = true
HeqHwf2: Hwf2 =
well_formed_free_evar_subst_0 E ψ1 q wfq
  wfψ1
Hwf3: well_formed ψ2^[[evar:E↦p]] = true
HeqHwf3: Hwf3 =
well_formed_free_evar_subst_0 E ψ2 p wfp
  wfψ2
Hwf4: well_formed ψ2^[[evar:E↦q]] = true
HeqHwf4: Hwf4 =
well_formed_free_evar_subst_0 E ψ2 q wfq
  wfψ2
well_formed (ψ2^[[evar:E↦q]] ---> ψ2^[[evar:E↦p]])
          {
Σ: Signature
Γ: Theory
ψ1, ψ2, p, q: Pattern
E: evar
i: ProofInfo
wfψ1: well_formed ψ1
wfψ2: well_formed ψ2
wfp: well_formed p
wfq: well_formed q
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]]
using i
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]]
using i
Hwf1: well_formed ψ1^[[evar:E↦p]] = true
HeqHwf1: Hwf1 =
well_formed_free_evar_subst_0 E ψ1 p wfp
  wfψ1
Hwf2: well_formed ψ1^[[evar:E↦q]] = true
HeqHwf2: Hwf2 =
well_formed_free_evar_subst_0 E ψ1 q wfq
  wfψ1
Hwf3: well_formed ψ2^[[evar:E↦p]] = true
HeqHwf3: Hwf3 =
well_formed_free_evar_subst_0 E ψ2 p wfp
  wfψ2
Hwf4: well_formed ψ2^[[evar:E↦q]] = true
HeqHwf4: Hwf4 =
well_formed_free_evar_subst_0 E ψ2 q wfq
  wfψ2
well_formed (ψ2^[[evar:E↦q]] ---> ψ2^[[evar:E↦p]]) abstract (wf_auto2). }
        }
      }
Σ: Signature
Γ: Theory
ψ1, ψ2, p, q: Pattern
E: evar
i: ProofInfo
wfψ1: well_formed ψ1
wfψ2: well_formed ψ2
wfp: well_formed p
wfq: well_formed q
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]]
using i
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]]
using i
Hwf1: well_formed ψ1^[[evar:E↦p]] = true
HeqHwf1: Hwf1 =
well_formed_free_evar_subst_0 E ψ1 p wfp
  wfψ1
Hwf2: well_formed ψ1^[[evar:E↦q]] = true
HeqHwf2: Hwf2 =
well_formed_free_evar_subst_0 E ψ1 q wfq
  wfψ1
Hwf3: well_formed ψ2^[[evar:E↦p]] = true
HeqHwf3: Hwf3 =
well_formed_free_evar_subst_0 E ψ2 p wfp
  wfψ2
Hwf4: well_formed ψ2^[[evar:E↦q]] = true
HeqHwf4: Hwf4 =
well_formed_free_evar_subst_0 E ψ2 q wfq
  wfψ2
well_formed
  (ψ1^[[evar:E↦q]] $ ψ2^[[evar:E↦p]] --->
   ψ1^[[evar:E↦q]] $ ψ2^[[evar:E↦q]])
Σ: Signature
Γ: Theory
ψ1, ψ2, p, q: Pattern
E: evar
i: ProofInfo
wfψ1: well_formed ψ1
wfψ2: well_formed ψ2
wfp: well_formed p
wfq: well_formed q
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]]
using i
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]]
using i
Hwf1: well_formed ψ1^[[evar:E↦p]] = true
HeqHwf1: Hwf1 =
well_formed_free_evar_subst_0 E ψ1 p wfp
  wfψ1
Hwf2: well_formed ψ1^[[evar:E↦q]] = true
HeqHwf2: Hwf2 =
well_formed_free_evar_subst_0 E ψ1 q wfq
  wfψ1
Hwf3: well_formed ψ2^[[evar:E↦p]] = true
HeqHwf3: Hwf3 =
well_formed_free_evar_subst_0 E ψ2 p wfp
  wfψ2
Hwf4: well_formed ψ2^[[evar:E↦q]] = true
HeqHwf4: Hwf4 =
well_formed_free_evar_subst_0 E ψ2 q wfq
  wfψ2
well_formed
  (ψ1^[[evar:E↦q]] $ ψ2^[[evar:E↦q]] --->
   ψ1^[[evar:E↦q]] $ ψ2^[[evar:E↦p]])
      {
Σ: Signature
Γ: Theory
ψ1, ψ2, p, q: Pattern
E: evar
i: ProofInfo
wfψ1: well_formed ψ1
wfψ2: well_formed ψ2
wfp: well_formed p
wfq: well_formed q
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]]
using i
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]]
using i
Hwf1: well_formed ψ1^[[evar:E↦p]] = true
HeqHwf1: Hwf1 =
well_formed_free_evar_subst_0 E ψ1 p wfp
  wfψ1
Hwf2: well_formed ψ1^[[evar:E↦q]] = true
HeqHwf2: Hwf2 =
well_formed_free_evar_subst_0 E ψ1 q wfq
  wfψ1
Hwf3: well_formed ψ2^[[evar:E↦p]] = true
HeqHwf3: Hwf3 =
well_formed_free_evar_subst_0 E ψ2 p wfp
  wfψ2
Hwf4: well_formed ψ2^[[evar:E↦q]] = true
HeqHwf4: Hwf4 =
well_formed_free_evar_subst_0 E ψ2 q wfq
  wfψ2
well_formed
  (ψ1^[[evar:E↦q]] $ ψ2^[[evar:E↦p]] --->
   ψ1^[[evar:E↦q]] $ ψ2^[[evar:E↦q]])
        abstract (wf_auto2).
      }
Σ: Signature
Γ: Theory
ψ1, ψ2, p, q: Pattern
E: evar
i: ProofInfo
wfψ1: well_formed ψ1
wfψ2: well_formed ψ2
wfp: well_formed p
wfq: well_formed q
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]]
using i
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]]
using i
Hwf1: well_formed ψ1^[[evar:E↦p]] = true
HeqHwf1: Hwf1 =
well_formed_free_evar_subst_0 E ψ1 p wfp
  wfψ1
Hwf2: well_formed ψ1^[[evar:E↦q]] = true
HeqHwf2: Hwf2 =
well_formed_free_evar_subst_0 E ψ1 q wfq
  wfψ1
Hwf3: well_formed ψ2^[[evar:E↦p]] = true
HeqHwf3: Hwf3 =
well_formed_free_evar_subst_0 E ψ2 p wfp
  wfψ2
Hwf4: well_formed ψ2^[[evar:E↦q]] = true
HeqHwf4: Hwf4 =
well_formed_free_evar_subst_0 E ψ2 q wfq
  wfψ2
well_formed
  (ψ1^[[evar:E↦q]] $ ψ2^[[evar:E↦q]] --->
   ψ1^[[evar:E↦q]] $ ψ2^[[evar:E↦p]])
      {
Σ: Signature
Γ: Theory
ψ1, ψ2, p, q: Pattern
E: evar
i: ProofInfo
wfψ1: well_formed ψ1
wfψ2: well_formed ψ2
wfp: well_formed p
wfq: well_formed q
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]]
using i
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]]
using i
Hwf1: well_formed ψ1^[[evar:E↦p]] = true
HeqHwf1: Hwf1 =
well_formed_free_evar_subst_0 E ψ1 p wfp
  wfψ1
Hwf2: well_formed ψ1^[[evar:E↦q]] = true
HeqHwf2: Hwf2 =
well_formed_free_evar_subst_0 E ψ1 q wfq
  wfψ1
Hwf3: well_formed ψ2^[[evar:E↦p]] = true
HeqHwf3: Hwf3 =
well_formed_free_evar_subst_0 E ψ2 p wfp
  wfψ2
Hwf4: well_formed ψ2^[[evar:E↦q]] = true
HeqHwf4: Hwf4 =
well_formed_free_evar_subst_0 E ψ2 q wfq
  wfψ2
well_formed
  (ψ1^[[evar:E↦q]] $ ψ2^[[evar:E↦q]] --->
   ψ1^[[evar:E↦q]] $ ψ2^[[evar:E↦p]])
        abstract (wf_auto2).
      }
    }
Σ: Signature
Γ: Theory
ψ1, ψ2, p, q: Pattern
E: evar
i: ProofInfo
wfψ1: well_formed ψ1
wfψ2: well_formed ψ2
wfp: well_formed p
wfq: well_formed q
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]]
using i
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]]
using i
Hwf1: well_formed ψ1^[[evar:E↦p]] = true
HeqHwf1: Hwf1 =
well_formed_free_evar_subst_0 E ψ1 p wfp
  wfψ1
Hwf2: well_formed ψ1^[[evar:E↦q]] = true
HeqHwf2: Hwf2 =
well_formed_free_evar_subst_0 E ψ1 q wfq
  wfψ1
Hwf3: well_formed ψ2^[[evar:E↦p]] = true
HeqHwf3: Hwf3 =
well_formed_free_evar_subst_0 E ψ2 p wfp
  wfψ2
Hwf4: well_formed ψ2^[[evar:E↦q]] = true
HeqHwf4: Hwf4 =
well_formed_free_evar_subst_0 E ψ2 q wfq
  wfψ2
well_formed (ψ1^[[evar:E↦p]] $ ψ2^[[evar:E↦p]])
Σ: Signature
Γ: Theory
ψ1, ψ2, p, q: Pattern
E: evar
i: ProofInfo
wfψ1: well_formed ψ1
wfψ2: well_formed ψ2
wfp: well_formed p
wfq: well_formed q
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]]
using i
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]]
using i
Hwf1: well_formed ψ1^[[evar:E↦p]] = true
HeqHwf1: Hwf1 =
well_formed_free_evar_subst_0 E ψ1 p wfp
  wfψ1
Hwf2: well_formed ψ1^[[evar:E↦q]] = true
HeqHwf2: Hwf2 =
well_formed_free_evar_subst_0 E ψ1 q wfq
  wfψ1
Hwf3: well_formed ψ2^[[evar:E↦p]] = true
HeqHwf3: Hwf3 =
well_formed_free_evar_subst_0 E ψ2 p wfp
  wfψ2
Hwf4: well_formed ψ2^[[evar:E↦q]] = true
HeqHwf4: Hwf4 =
well_formed_free_evar_subst_0 E ψ2 q wfq
  wfψ2
well_formed (ψ1^[[evar:E↦q]] $ ψ2^[[evar:E↦p]])
Σ: Signature
Γ: Theory
ψ1, ψ2, p, q: Pattern
E: evar
i: ProofInfo
wfψ1: well_formed ψ1
wfψ2: well_formed ψ2
wfp: well_formed p
wfq: well_formed q
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]]
using i
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]]
using i
Hwf1: well_formed ψ1^[[evar:E↦p]] = true
HeqHwf1: Hwf1 =
well_formed_free_evar_subst_0 E ψ1 p wfp
  wfψ1
Hwf2: well_formed ψ1^[[evar:E↦q]] = true
HeqHwf2: Hwf2 =
well_formed_free_evar_subst_0 E ψ1 q wfq
  wfψ1
Hwf3: well_formed ψ2^[[evar:E↦p]] = true
HeqHwf3: Hwf3 =
well_formed_free_evar_subst_0 E ψ2 p wfp
  wfψ2
Hwf4: well_formed ψ2^[[evar:E↦q]] = true
HeqHwf4: Hwf4 =
well_formed_free_evar_subst_0 E ψ2 q wfq
  wfψ2
well_formed (ψ1^[[evar:E↦q]] $ ψ2^[[evar:E↦q]])
Σ: Signature
Γ: Theory
ψ1, ψ2, p, q: Pattern
E: evar
i: ProofInfo
wfψ1: well_formed ψ1
wfψ2: well_formed ψ2
wfp: well_formed p
wfq: well_formed q
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]]
using i
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]]
using i
Hwf1: well_formed ψ1^[[evar:E↦p]] = true
HeqHwf1: Hwf1 =
well_formed_free_evar_subst_0 E ψ1 p wfp
  wfψ1
Hwf2: well_formed ψ1^[[evar:E↦q]] = true
HeqHwf2: Hwf2 =
well_formed_free_evar_subst_0 E ψ1 q wfq
  wfψ1
Hwf3: well_formed ψ2^[[evar:E↦p]] = true
HeqHwf3: Hwf3 =
well_formed_free_evar_subst_0 E ψ2 p wfp
  wfψ2
Hwf4: well_formed ψ2^[[evar:E↦q]] = true
HeqHwf4: Hwf4 =
well_formed_free_evar_subst_0 E ψ2 q wfq
  wfψ2
Γ
⊢i ψ1^[[evar:E↦p]] $ ψ2^[[evar:E↦p]] <--->
   ψ1^[[evar:E↦q]] $ ψ2^[[evar:E↦p]] using i
    4: {
Σ: Signature
Γ: Theory
ψ1, ψ2, p, q: Pattern
E: evar
i: ProofInfo
wfψ1: well_formed ψ1
wfψ2: well_formed ψ2
wfp: well_formed p
wfq: well_formed q
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]]
using i
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]]
using i
Hwf1: well_formed ψ1^[[evar:E↦p]] = true
HeqHwf1: Hwf1 =
well_formed_free_evar_subst_0 E ψ1 p wfp
  wfψ1
Hwf2: well_formed ψ1^[[evar:E↦q]] = true
HeqHwf2: Hwf2 =
well_formed_free_evar_subst_0 E ψ1 q wfq
  wfψ1
Hwf3: well_formed ψ2^[[evar:E↦p]] = true
HeqHwf3: Hwf3 =
well_formed_free_evar_subst_0 E ψ2 p wfp
  wfψ2
Hwf4: well_formed ψ2^[[evar:E↦q]] = true
HeqHwf4: Hwf4 =
well_formed_free_evar_subst_0 E ψ2 q wfq
  wfψ2
Γ
⊢i ψ1^[[evar:E↦p]] $ ψ2^[[evar:E↦p]] <--->
   ψ1^[[evar:E↦q]] $ ψ2^[[evar:E↦p]] using i
      apply conj_intro_meta.
Σ: Signature
Γ: Theory
ψ1, ψ2, p, q: Pattern
E: evar
i: ProofInfo
wfψ1: well_formed ψ1
wfψ2: well_formed ψ2
wfp: well_formed p
wfq: well_formed q
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]]
using i
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]]
using i
Hwf1: well_formed ψ1^[[evar:E↦p]] = true
HeqHwf1: Hwf1 =
well_formed_free_evar_subst_0 E ψ1 p wfp
  wfψ1
Hwf2: well_formed ψ1^[[evar:E↦q]] = true
HeqHwf2: Hwf2 =
well_formed_free_evar_subst_0 E ψ1 q wfq
  wfψ1
Hwf3: well_formed ψ2^[[evar:E↦p]] = true
HeqHwf3: Hwf3 =
well_formed_free_evar_subst_0 E ψ2 p wfp
  wfψ2
Hwf4: well_formed ψ2^[[evar:E↦q]] = true
HeqHwf4: Hwf4 =
well_formed_free_evar_subst_0 E ψ2 q wfq
  wfψ2
well_formed
  (ψ1^[[evar:E↦p]] $ ψ2^[[evar:E↦p]] --->
   ψ1^[[evar:E↦q]] $ ψ2^[[evar:E↦p]])
Σ: Signature
Γ: Theory
ψ1, ψ2, p, q: Pattern
E: evar
i: ProofInfo
wfψ1: well_formed ψ1
wfψ2: well_formed ψ2
wfp: well_formed p
wfq: well_formed q
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]]
using i
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]]
using i
Hwf1: well_formed ψ1^[[evar:E↦p]] = true
HeqHwf1: Hwf1 =
well_formed_free_evar_subst_0 E ψ1 p wfp
  wfψ1
Hwf2: well_formed ψ1^[[evar:E↦q]] = true
HeqHwf2: Hwf2 =
well_formed_free_evar_subst_0 E ψ1 q wfq
  wfψ1
Hwf3: well_formed ψ2^[[evar:E↦p]] = true
HeqHwf3: Hwf3 =
well_formed_free_evar_subst_0 E ψ2 p wfp
  wfψ2
Hwf4: well_formed ψ2^[[evar:E↦q]] = true
HeqHwf4: Hwf4 =
well_formed_free_evar_subst_0 E ψ2 q wfq
  wfψ2
well_formed
  (ψ1^[[evar:E↦q]] $ ψ2^[[evar:E↦p]] --->
   ψ1^[[evar:E↦p]] $ ψ2^[[evar:E↦p]])
Σ: Signature
Γ: Theory
ψ1, ψ2, p, q: Pattern
E: evar
i: ProofInfo
wfψ1: well_formed ψ1
wfψ2: well_formed ψ2
wfp: well_formed p
wfq: well_formed q
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]]
using i
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]]
using i
Hwf1: well_formed ψ1^[[evar:E↦p]] = true
HeqHwf1: Hwf1 =
well_formed_free_evar_subst_0 E ψ1 p wfp
  wfψ1
Hwf2: well_formed ψ1^[[evar:E↦q]] = true
HeqHwf2: Hwf2 =
well_formed_free_evar_subst_0 E ψ1 q wfq
  wfψ1
Hwf3: well_formed ψ2^[[evar:E↦p]] = true
HeqHwf3: Hwf3 =
well_formed_free_evar_subst_0 E ψ2 p wfp
  wfψ2
Hwf4: well_formed ψ2^[[evar:E↦q]] = true
HeqHwf4: Hwf4 =
well_formed_free_evar_subst_0 E ψ2 q wfq
  wfψ2
Γ
⊢i ψ1^[[evar:E↦p]] $ ψ2^[[evar:E↦p]] --->
   ψ1^[[evar:E↦q]] $ ψ2^[[evar:E↦p]] using i
Σ: Signature
Γ: Theory
ψ1, ψ2, p, q: Pattern
E: evar
i: ProofInfo
wfψ1: well_formed ψ1
wfψ2: well_formed ψ2
wfp: well_formed p
wfq: well_formed q
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]]
using i
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]]
using i
Hwf1: well_formed ψ1^[[evar:E↦p]] = true
HeqHwf1: Hwf1 =
well_formed_free_evar_subst_0 E ψ1 p wfp
  wfψ1
Hwf2: well_formed ψ1^[[evar:E↦q]] = true
HeqHwf2: Hwf2 =
well_formed_free_evar_subst_0 E ψ1 q wfq
  wfψ1
Hwf3: well_formed ψ2^[[evar:E↦p]] = true
HeqHwf3: Hwf3 =
well_formed_free_evar_subst_0 E ψ2 p wfp
  wfψ2
Hwf4: well_formed ψ2^[[evar:E↦q]] = true
HeqHwf4: Hwf4 =
well_formed_free_evar_subst_0 E ψ2 q wfq
  wfψ2
Γ
⊢i ψ1^[[evar:E↦q]] $ ψ2^[[evar:E↦p]] --->
   ψ1^[[evar:E↦p]] $ ψ2^[[evar:E↦p]] using i
      4: {
Σ: Signature
Γ: Theory
ψ1, ψ2, p, q: Pattern
E: evar
i: ProofInfo
wfψ1: well_formed ψ1
wfψ2: well_formed ψ2
wfp: well_formed p
wfq: well_formed q
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]]
using i
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]]
using i
Hwf1: well_formed ψ1^[[evar:E↦p]] = true
HeqHwf1: Hwf1 =
well_formed_free_evar_subst_0 E ψ1 p wfp
  wfψ1
Hwf2: well_formed ψ1^[[evar:E↦q]] = true
HeqHwf2: Hwf2 =
well_formed_free_evar_subst_0 E ψ1 q wfq
  wfψ1
Hwf3: well_formed ψ2^[[evar:E↦p]] = true
HeqHwf3: Hwf3 =
well_formed_free_evar_subst_0 E ψ2 p wfp
  wfψ2
Hwf4: well_formed ψ2^[[evar:E↦q]] = true
HeqHwf4: Hwf4 =
well_formed_free_evar_subst_0 E ψ2 q wfq
  wfψ2
Γ
⊢i ψ1^[[evar:E↦q]] $ ψ2^[[evar:E↦p]] --->
   ψ1^[[evar:E↦p]] $ ψ2^[[evar:E↦p]] using i
        apply Framing_left with (ψ := ψ2^[[evar: E ↦ p]]); auto.
Σ: Signature
Γ: Theory
ψ1, ψ2, p, q: Pattern
E: evar
i: ProofInfo
wfψ1: well_formed ψ1
wfψ2: well_formed ψ2
wfp: well_formed p
wfq: well_formed q
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]]
using i
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]]
using i
Hwf1: well_formed ψ1^[[evar:E↦p]] = true
HeqHwf1: Hwf1 =
well_formed_free_evar_subst_0 E ψ1 p wfp
  wfψ1
Hwf2: well_formed ψ1^[[evar:E↦q]] = true
HeqHwf2: Hwf2 =
well_formed_free_evar_subst_0 E ψ1 q wfq
  wfψ1
Hwf3: well_formed ψ2^[[evar:E↦p]] = true
HeqHwf3: Hwf3 =
well_formed_free_evar_subst_0 E ψ2 p wfp
  wfψ2
Hwf4: well_formed ψ2^[[evar:E↦q]] = true
HeqHwf4: Hwf4 =
well_formed_free_evar_subst_0 E ψ2 q wfq
  wfψ2
ProofInfoLe (ExGen := ∅, SVSubst := ∅, KT := false) i
Σ: Signature
Γ: Theory
ψ1, ψ2, p, q: Pattern
E: evar
i: ProofInfo
wfψ1: well_formed ψ1
wfψ2: well_formed ψ2
wfp: well_formed p
wfq: well_formed q
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]]
using i
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]]
using i
Hwf1: well_formed ψ1^[[evar:E↦p]] = true
HeqHwf1: Hwf1 =
well_formed_free_evar_subst_0 E ψ1 p wfp
  wfψ1
Hwf2: well_formed ψ1^[[evar:E↦q]] = true
HeqHwf2: Hwf2 =
well_formed_free_evar_subst_0 E ψ1 q wfq
  wfψ1
Hwf3: well_formed ψ2^[[evar:E↦p]] = true
HeqHwf3: Hwf3 =
well_formed_free_evar_subst_0 E ψ2 p wfp
  wfψ2
Hwf4: well_formed ψ2^[[evar:E↦q]] = true
HeqHwf4: Hwf4 =
well_formed_free_evar_subst_0 E ψ2 q wfq
  wfψ2
Γ ⊢i ψ1^[[evar:E↦q]] ---> ψ1^[[evar:E↦p]] using i
        {
Σ: Signature
Γ: Theory
ψ1, ψ2, p, q: Pattern
E: evar
i: ProofInfo
wfψ1: well_formed ψ1
wfψ2: well_formed ψ2
wfp: well_formed p
wfq: well_formed q
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]]
using i
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]]
using i
Hwf1: well_formed ψ1^[[evar:E↦p]] = true
HeqHwf1: Hwf1 =
well_formed_free_evar_subst_0 E ψ1 p wfp
  wfψ1
Hwf2: well_formed ψ1^[[evar:E↦q]] = true
HeqHwf2: Hwf2 =
well_formed_free_evar_subst_0 E ψ1 q wfq
  wfψ1
Hwf3: well_formed ψ2^[[evar:E↦p]] = true
HeqHwf3: Hwf3 =
well_formed_free_evar_subst_0 E ψ2 p wfp
  wfψ2
Hwf4: well_formed ψ2^[[evar:E↦q]] = true
HeqHwf4: Hwf4 =
well_formed_free_evar_subst_0 E ψ2 q wfq
  wfψ2
ProofInfoLe (ExGen := ∅, SVSubst := ∅, KT := false) i try_solve_pile. }
Σ: Signature
Γ: Theory
ψ1, ψ2, p, q: Pattern
E: evar
i: ProofInfo
wfψ1: well_formed ψ1
wfψ2: well_formed ψ2
wfp: well_formed p
wfq: well_formed q
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]]
using i
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]]
using i
Hwf1: well_formed ψ1^[[evar:E↦p]] = true
HeqHwf1: Hwf1 =
well_formed_free_evar_subst_0 E ψ1 p wfp
  wfψ1
Hwf2: well_formed ψ1^[[evar:E↦q]] = true
HeqHwf2: Hwf2 =
well_formed_free_evar_subst_0 E ψ1 q wfq
  wfψ1
Hwf3: well_formed ψ2^[[evar:E↦p]] = true
HeqHwf3: Hwf3 =
well_formed_free_evar_subst_0 E ψ2 p wfp
  wfψ2
Hwf4: well_formed ψ2^[[evar:E↦q]] = true
HeqHwf4: Hwf4 =
well_formed_free_evar_subst_0 E ψ2 q wfq
  wfψ2
Γ ⊢i ψ1^[[evar:E↦q]] ---> ψ1^[[evar:E↦p]] using i
        {
Σ: Signature
Γ: Theory
ψ1, ψ2, p, q: Pattern
E: evar
i: ProofInfo
wfψ1: well_formed ψ1
wfψ2: well_formed ψ2
wfp: well_formed p
wfq: well_formed q
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]]
using i
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]]
using i
Hwf1: well_formed ψ1^[[evar:E↦p]] = true
HeqHwf1: Hwf1 =
well_formed_free_evar_subst_0 E ψ1 p wfp
  wfψ1
Hwf2: well_formed ψ1^[[evar:E↦q]] = true
HeqHwf2: Hwf2 =
well_formed_free_evar_subst_0 E ψ1 q wfq
  wfψ1
Hwf3: well_formed ψ2^[[evar:E↦p]] = true
HeqHwf3: Hwf3 =
well_formed_free_evar_subst_0 E ψ2 p wfp
  wfψ2
Hwf4: well_formed ψ2^[[evar:E↦q]] = true
HeqHwf4: Hwf4 =
well_formed_free_evar_subst_0 E ψ2 q wfq
  wfψ2
Γ ⊢i ψ1^[[evar:E↦q]] ---> ψ1^[[evar:E↦p]] using i
          eapply pf_conj_elim_r_meta in pf₁.
Σ: Signature
Γ: Theory
ψ1, ψ2, p, q: Pattern
E: evar
i: ProofInfo
wfψ1: well_formed ψ1
wfψ2: well_formed ψ2
wfp: well_formed p
wfq: well_formed q
pf₁: Γ ⊢i ψ1^[[evar:E↦q]] ---> ψ1^[[evar:E↦p]]
using i
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]]
using i
Hwf1: well_formed ψ1^[[evar:E↦p]] = true
HeqHwf1: Hwf1 =
well_formed_free_evar_subst_0 E ψ1 p wfp
  wfψ1
Hwf2: well_formed ψ1^[[evar:E↦q]] = true
HeqHwf2: Hwf2 =
well_formed_free_evar_subst_0 E ψ1 q wfq
  wfψ1
Hwf3: well_formed ψ2^[[evar:E↦p]] = true
HeqHwf3: Hwf3 =
well_formed_free_evar_subst_0 E ψ2 p wfp
  wfψ2
Hwf4: well_formed ψ2^[[evar:E↦q]] = true
HeqHwf4: Hwf4 =
well_formed_free_evar_subst_0 E ψ2 q wfq
  wfψ2
Γ ⊢i ψ1^[[evar:E↦q]] ---> ψ1^[[evar:E↦p]] using i
Σ: Signature
Γ: Theory
ψ1, ψ2, p, q: Pattern
E: evar
i: ProofInfo
wfψ1: well_formed ψ1
wfψ2: well_formed ψ2
wfp: well_formed p
wfq: well_formed q
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]]
using i
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]]
using i
Hwf1: well_formed ψ1^[[evar:E↦p]] = true
HeqHwf1: Hwf1 =
well_formed_free_evar_subst_0 E ψ1 p wfp
  wfψ1
Hwf2: well_formed ψ1^[[evar:E↦q]] = true
HeqHwf2: Hwf2 =
well_formed_free_evar_subst_0 E ψ1 q wfq
  wfψ1
Hwf3: well_formed ψ2^[[evar:E↦p]] = true
HeqHwf3: Hwf3 =
well_formed_free_evar_subst_0 E ψ2 p wfp
  wfψ2
Hwf4: well_formed ψ2^[[evar:E↦q]] = true
HeqHwf4: Hwf4 =
well_formed_free_evar_subst_0 E ψ2 q wfq
  wfψ2
well_formed (ψ1^[[evar:E↦p]] ---> ψ1^[[evar:E↦q]])
Σ: Signature
Γ: Theory
ψ1, ψ2, p, q: Pattern
E: evar
i: ProofInfo
wfψ1: well_formed ψ1
wfψ2: well_formed ψ2
wfp: well_formed p
wfq: well_formed q
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]]
using i
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]]
using i
Hwf1: well_formed ψ1^[[evar:E↦p]] = true
HeqHwf1: Hwf1 =
well_formed_free_evar_subst_0 E ψ1 p wfp
  wfψ1
Hwf2: well_formed ψ1^[[evar:E↦q]] = true
HeqHwf2: Hwf2 =
well_formed_free_evar_subst_0 E ψ1 q wfq
  wfψ1
Hwf3: well_formed ψ2^[[evar:E↦p]] = true
HeqHwf3: Hwf3 =
well_formed_free_evar_subst_0 E ψ2 p wfp
  wfψ2
Hwf4: well_formed ψ2^[[evar:E↦q]] = true
HeqHwf4: Hwf4 =
well_formed_free_evar_subst_0 E ψ2 q wfq
  wfψ2
well_formed (ψ1^[[evar:E↦q]] ---> ψ1^[[evar:E↦p]])
          apply pf₁.
Σ: Signature
Γ: Theory
ψ1, ψ2, p, q: Pattern
E: evar
i: ProofInfo
wfψ1: well_formed ψ1
wfψ2: well_formed ψ2
wfp: well_formed p
wfq: well_formed q
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]]
using i
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]]
using i
Hwf1: well_formed ψ1^[[evar:E↦p]] = true
HeqHwf1: Hwf1 =
well_formed_free_evar_subst_0 E ψ1 p wfp
  wfψ1
Hwf2: well_formed ψ1^[[evar:E↦q]] = true
HeqHwf2: Hwf2 =
well_formed_free_evar_subst_0 E ψ1 q wfq
  wfψ1
Hwf3: well_formed ψ2^[[evar:E↦p]] = true
HeqHwf3: Hwf3 =
well_formed_free_evar_subst_0 E ψ2 p wfp
  wfψ2
Hwf4: well_formed ψ2^[[evar:E↦q]] = true
HeqHwf4: Hwf4 =
well_formed_free_evar_subst_0 E ψ2 q wfq
  wfψ2
well_formed (ψ1^[[evar:E↦p]] ---> ψ1^[[evar:E↦q]])
Σ: Signature
Γ: Theory
ψ1, ψ2, p, q: Pattern
E: evar
i: ProofInfo
wfψ1: well_formed ψ1
wfψ2: well_formed ψ2
wfp: well_formed p
wfq: well_formed q
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]]
using i
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]]
using i
Hwf1: well_formed ψ1^[[evar:E↦p]] = true
HeqHwf1: Hwf1 =
well_formed_free_evar_subst_0 E ψ1 p wfp
  wfψ1
Hwf2: well_formed ψ1^[[evar:E↦q]] = true
HeqHwf2: Hwf2 =
well_formed_free_evar_subst_0 E ψ1 q wfq
  wfψ1
Hwf3: well_formed ψ2^[[evar:E↦p]] = true
HeqHwf3: Hwf3 =
well_formed_free_evar_subst_0 E ψ2 p wfp
  wfψ2
Hwf4: well_formed ψ2^[[evar:E↦q]] = true
HeqHwf4: Hwf4 =
well_formed_free_evar_subst_0 E ψ2 q wfq
  wfψ2
well_formed (ψ1^[[evar:E↦q]] ---> ψ1^[[evar:E↦p]])
          {
Σ: Signature
Γ: Theory
ψ1, ψ2, p, q: Pattern
E: evar
i: ProofInfo
wfψ1: well_formed ψ1
wfψ2: well_formed ψ2
wfp: well_formed p
wfq: well_formed q
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]]
using i
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]]
using i
Hwf1: well_formed ψ1^[[evar:E↦p]] = true
HeqHwf1: Hwf1 =
well_formed_free_evar_subst_0 E ψ1 p wfp
  wfψ1
Hwf2: well_formed ψ1^[[evar:E↦q]] = true
HeqHwf2: Hwf2 =
well_formed_free_evar_subst_0 E ψ1 q wfq
  wfψ1
Hwf3: well_formed ψ2^[[evar:E↦p]] = true
HeqHwf3: Hwf3 =
well_formed_free_evar_subst_0 E ψ2 p wfp
  wfψ2
Hwf4: well_formed ψ2^[[evar:E↦q]] = true
HeqHwf4: Hwf4 =
well_formed_free_evar_subst_0 E ψ2 q wfq
  wfψ2
well_formed (ψ1^[[evar:E↦p]] ---> ψ1^[[evar:E↦q]]) abstract (wf_auto2). }
Σ: Signature
Γ: Theory
ψ1, ψ2, p, q: Pattern
E: evar
i: ProofInfo
wfψ1: well_formed ψ1
wfψ2: well_formed ψ2
wfp: well_formed p
wfq: well_formed q
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]]
using i
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]]
using i
Hwf1: well_formed ψ1^[[evar:E↦p]] = true
HeqHwf1: Hwf1 =
well_formed_free_evar_subst_0 E ψ1 p wfp
  wfψ1
Hwf2: well_formed ψ1^[[evar:E↦q]] = true
HeqHwf2: Hwf2 =
well_formed_free_evar_subst_0 E ψ1 q wfq
  wfψ1
Hwf3: well_formed ψ2^[[evar:E↦p]] = true
HeqHwf3: Hwf3 =
well_formed_free_evar_subst_0 E ψ2 p wfp
  wfψ2
Hwf4: well_formed ψ2^[[evar:E↦q]] = true
HeqHwf4: Hwf4 =
well_formed_free_evar_subst_0 E ψ2 q wfq
  wfψ2
well_formed (ψ1^[[evar:E↦q]] ---> ψ1^[[evar:E↦p]])
          {
Σ: Signature
Γ: Theory
ψ1, ψ2, p, q: Pattern
E: evar
i: ProofInfo
wfψ1: well_formed ψ1
wfψ2: well_formed ψ2
wfp: well_formed p
wfq: well_formed q
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]]
using i
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]]
using i
Hwf1: well_formed ψ1^[[evar:E↦p]] = true
HeqHwf1: Hwf1 =
well_formed_free_evar_subst_0 E ψ1 p wfp
  wfψ1
Hwf2: well_formed ψ1^[[evar:E↦q]] = true
HeqHwf2: Hwf2 =
well_formed_free_evar_subst_0 E ψ1 q wfq
  wfψ1
Hwf3: well_formed ψ2^[[evar:E↦p]] = true
HeqHwf3: Hwf3 =
well_formed_free_evar_subst_0 E ψ2 p wfp
  wfψ2
Hwf4: well_formed ψ2^[[evar:E↦q]] = true
HeqHwf4: Hwf4 =
well_formed_free_evar_subst_0 E ψ2 q wfq
  wfψ2
well_formed (ψ1^[[evar:E↦q]] ---> ψ1^[[evar:E↦p]]) abstract (wf_auto2). }
        }
      }
Σ: Signature
Γ: Theory
ψ1, ψ2, p, q: Pattern
E: evar
i: ProofInfo
wfψ1: well_formed ψ1
wfψ2: well_formed ψ2
wfp: well_formed p
wfq: well_formed q
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]]
using i
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]]
using i
Hwf1: well_formed ψ1^[[evar:E↦p]] = true
HeqHwf1: Hwf1 =
well_formed_free_evar_subst_0 E ψ1 p wfp
  wfψ1
Hwf2: well_formed ψ1^[[evar:E↦q]] = true
HeqHwf2: Hwf2 =
well_formed_free_evar_subst_0 E ψ1 q wfq
  wfψ1
Hwf3: well_formed ψ2^[[evar:E↦p]] = true
HeqHwf3: Hwf3 =
well_formed_free_evar_subst_0 E ψ2 p wfp
  wfψ2
Hwf4: well_formed ψ2^[[evar:E↦q]] = true
HeqHwf4: Hwf4 =
well_formed_free_evar_subst_0 E ψ2 q wfq
  wfψ2
well_formed
  (ψ1^[[evar:E↦p]] $ ψ2^[[evar:E↦p]] --->
   ψ1^[[evar:E↦q]] $ ψ2^[[evar:E↦p]])
Σ: Signature
Γ: Theory
ψ1, ψ2, p, q: Pattern
E: evar
i: ProofInfo
wfψ1: well_formed ψ1
wfψ2: well_formed ψ2
wfp: well_formed p
wfq: well_formed q
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]]
using i
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]]
using i
Hwf1: well_formed ψ1^[[evar:E↦p]] = true
HeqHwf1: Hwf1 =
well_formed_free_evar_subst_0 E ψ1 p wfp
  wfψ1
Hwf2: well_formed ψ1^[[evar:E↦q]] = true
HeqHwf2: Hwf2 =
well_formed_free_evar_subst_0 E ψ1 q wfq
  wfψ1
Hwf3: well_formed ψ2^[[evar:E↦p]] = true
HeqHwf3: Hwf3 =
well_formed_free_evar_subst_0 E ψ2 p wfp
  wfψ2
Hwf4: well_formed ψ2^[[evar:E↦q]] = true
HeqHwf4: Hwf4 =
well_formed_free_evar_subst_0 E ψ2 q wfq
  wfψ2
well_formed
  (ψ1^[[evar:E↦q]] $ ψ2^[[evar:E↦p]] --->
   ψ1^[[evar:E↦p]] $ ψ2^[[evar:E↦p]])
Σ: Signature
Γ: Theory
ψ1, ψ2, p, q: Pattern
E: evar
i: ProofInfo
wfψ1: well_formed ψ1
wfψ2: well_formed ψ2
wfp: well_formed p
wfq: well_formed q
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]]
using i
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]]
using i
Hwf1: well_formed ψ1^[[evar:E↦p]] = true
HeqHwf1: Hwf1 =
well_formed_free_evar_subst_0 E ψ1 p wfp
  wfψ1
Hwf2: well_formed ψ1^[[evar:E↦q]] = true
HeqHwf2: Hwf2 =
well_formed_free_evar_subst_0 E ψ1 q wfq
  wfψ1
Hwf3: well_formed ψ2^[[evar:E↦p]] = true
HeqHwf3: Hwf3 =
well_formed_free_evar_subst_0 E ψ2 p wfp
  wfψ2
Hwf4: well_formed ψ2^[[evar:E↦q]] = true
HeqHwf4: Hwf4 =
well_formed_free_evar_subst_0 E ψ2 q wfq
  wfψ2
Γ
⊢i ψ1^[[evar:E↦p]] $ ψ2^[[evar:E↦p]] --->
   ψ1^[[evar:E↦q]] $ ψ2^[[evar:E↦p]] using i
      3: {
Σ: Signature
Γ: Theory
ψ1, ψ2, p, q: Pattern
E: evar
i: ProofInfo
wfψ1: well_formed ψ1
wfψ2: well_formed ψ2
wfp: well_formed p
wfq: well_formed q
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]]
using i
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]]
using i
Hwf1: well_formed ψ1^[[evar:E↦p]] = true
HeqHwf1: Hwf1 =
well_formed_free_evar_subst_0 E ψ1 p wfp
  wfψ1
Hwf2: well_formed ψ1^[[evar:E↦q]] = true
HeqHwf2: Hwf2 =
well_formed_free_evar_subst_0 E ψ1 q wfq
  wfψ1
Hwf3: well_formed ψ2^[[evar:E↦p]] = true
HeqHwf3: Hwf3 =
well_formed_free_evar_subst_0 E ψ2 p wfp
  wfψ2
Hwf4: well_formed ψ2^[[evar:E↦q]] = true
HeqHwf4: Hwf4 =
well_formed_free_evar_subst_0 E ψ2 q wfq
  wfψ2
Γ
⊢i ψ1^[[evar:E↦p]] $ ψ2^[[evar:E↦p]] --->
   ψ1^[[evar:E↦q]] $ ψ2^[[evar:E↦p]] using i
        apply Framing_left with (ψ := ψ2^[[evar: E ↦ p]]); auto.
Σ: Signature
Γ: Theory
ψ1, ψ2, p, q: Pattern
E: evar
i: ProofInfo
wfψ1: well_formed ψ1
wfψ2: well_formed ψ2
wfp: well_formed p
wfq: well_formed q
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]]
using i
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]]
using i
Hwf1: well_formed ψ1^[[evar:E↦p]] = true
HeqHwf1: Hwf1 =
well_formed_free_evar_subst_0 E ψ1 p wfp
  wfψ1
Hwf2: well_formed ψ1^[[evar:E↦q]] = true
HeqHwf2: Hwf2 =
well_formed_free_evar_subst_0 E ψ1 q wfq
  wfψ1
Hwf3: well_formed ψ2^[[evar:E↦p]] = true
HeqHwf3: Hwf3 =
well_formed_free_evar_subst_0 E ψ2 p wfp
  wfψ2
Hwf4: well_formed ψ2^[[evar:E↦q]] = true
HeqHwf4: Hwf4 =
well_formed_free_evar_subst_0 E ψ2 q wfq
  wfψ2
ProofInfoLe (ExGen := ∅, SVSubst := ∅, KT := false) i
Σ: Signature
Γ: Theory
ψ1, ψ2, p, q: Pattern
E: evar
i: ProofInfo
wfψ1: well_formed ψ1
wfψ2: well_formed ψ2
wfp: well_formed p
wfq: well_formed q
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]]
using i
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]]
using i
Hwf1: well_formed ψ1^[[evar:E↦p]] = true
HeqHwf1: Hwf1 =
well_formed_free_evar_subst_0 E ψ1 p wfp
  wfψ1
Hwf2: well_formed ψ1^[[evar:E↦q]] = true
HeqHwf2: Hwf2 =
well_formed_free_evar_subst_0 E ψ1 q wfq
  wfψ1
Hwf3: well_formed ψ2^[[evar:E↦p]] = true
HeqHwf3: Hwf3 =
well_formed_free_evar_subst_0 E ψ2 p wfp
  wfψ2
Hwf4: well_formed ψ2^[[evar:E↦q]] = true
HeqHwf4: Hwf4 =
well_formed_free_evar_subst_0 E ψ2 q wfq
  wfψ2
Γ ⊢i ψ1^[[evar:E↦p]] ---> ψ1^[[evar:E↦q]] using i
        {
Σ: Signature
Γ: Theory
ψ1, ψ2, p, q: Pattern
E: evar
i: ProofInfo
wfψ1: well_formed ψ1
wfψ2: well_formed ψ2
wfp: well_formed p
wfq: well_formed q
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]]
using i
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]]
using i
Hwf1: well_formed ψ1^[[evar:E↦p]] = true
HeqHwf1: Hwf1 =
well_formed_free_evar_subst_0 E ψ1 p wfp
  wfψ1
Hwf2: well_formed ψ1^[[evar:E↦q]] = true
HeqHwf2: Hwf2 =
well_formed_free_evar_subst_0 E ψ1 q wfq
  wfψ1
Hwf3: well_formed ψ2^[[evar:E↦p]] = true
HeqHwf3: Hwf3 =
well_formed_free_evar_subst_0 E ψ2 p wfp
  wfψ2
Hwf4: well_formed ψ2^[[evar:E↦q]] = true
HeqHwf4: Hwf4 =
well_formed_free_evar_subst_0 E ψ2 q wfq
  wfψ2
ProofInfoLe (ExGen := ∅, SVSubst := ∅, KT := false) i try_solve_pile. }
Σ: Signature
Γ: Theory
ψ1, ψ2, p, q: Pattern
E: evar
i: ProofInfo
wfψ1: well_formed ψ1
wfψ2: well_formed ψ2
wfp: well_formed p
wfq: well_formed q
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]]
using i
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]]
using i
Hwf1: well_formed ψ1^[[evar:E↦p]] = true
HeqHwf1: Hwf1 =
well_formed_free_evar_subst_0 E ψ1 p wfp
  wfψ1
Hwf2: well_formed ψ1^[[evar:E↦q]] = true
HeqHwf2: Hwf2 =
well_formed_free_evar_subst_0 E ψ1 q wfq
  wfψ1
Hwf3: well_formed ψ2^[[evar:E↦p]] = true
HeqHwf3: Hwf3 =
well_formed_free_evar_subst_0 E ψ2 p wfp
  wfψ2
Hwf4: well_formed ψ2^[[evar:E↦q]] = true
HeqHwf4: Hwf4 =
well_formed_free_evar_subst_0 E ψ2 q wfq
  wfψ2
Γ ⊢i ψ1^[[evar:E↦p]] ---> ψ1^[[evar:E↦q]] using i
        {
Σ: Signature
Γ: Theory
ψ1, ψ2, p, q: Pattern
E: evar
i: ProofInfo
wfψ1: well_formed ψ1
wfψ2: well_formed ψ2
wfp: well_formed p
wfq: well_formed q
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]]
using i
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]]
using i
Hwf1: well_formed ψ1^[[evar:E↦p]] = true
HeqHwf1: Hwf1 =
well_formed_free_evar_subst_0 E ψ1 p wfp
  wfψ1
Hwf2: well_formed ψ1^[[evar:E↦q]] = true
HeqHwf2: Hwf2 =
well_formed_free_evar_subst_0 E ψ1 q wfq
  wfψ1
Hwf3: well_formed ψ2^[[evar:E↦p]] = true
HeqHwf3: Hwf3 =
well_formed_free_evar_subst_0 E ψ2 p wfp
  wfψ2
Hwf4: well_formed ψ2^[[evar:E↦q]] = true
HeqHwf4: Hwf4 =
well_formed_free_evar_subst_0 E ψ2 q wfq
  wfψ2
Γ ⊢i ψ1^[[evar:E↦p]] ---> ψ1^[[evar:E↦q]] using i
          eapply pf_conj_elim_l_meta in pf₁.
Σ: Signature
Γ: Theory
ψ1, ψ2, p, q: Pattern
E: evar
i: ProofInfo
wfψ1: well_formed ψ1
wfψ2: well_formed ψ2
wfp: well_formed p
wfq: well_formed q
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] ---> ψ1^[[evar:E↦q]]
using i
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]]
using i
Hwf1: well_formed ψ1^[[evar:E↦p]] = true
HeqHwf1: Hwf1 =
well_formed_free_evar_subst_0 E ψ1 p wfp
  wfψ1
Hwf2: well_formed ψ1^[[evar:E↦q]] = true
HeqHwf2: Hwf2 =
well_formed_free_evar_subst_0 E ψ1 q wfq
  wfψ1
Hwf3: well_formed ψ2^[[evar:E↦p]] = true
HeqHwf3: Hwf3 =
well_formed_free_evar_subst_0 E ψ2 p wfp
  wfψ2
Hwf4: well_formed ψ2^[[evar:E↦q]] = true
HeqHwf4: Hwf4 =
well_formed_free_evar_subst_0 E ψ2 q wfq
  wfψ2
Γ ⊢i ψ1^[[evar:E↦p]] ---> ψ1^[[evar:E↦q]] using i
Σ: Signature
Γ: Theory
ψ1, ψ2, p, q: Pattern
E: evar
i: ProofInfo
wfψ1: well_formed ψ1
wfψ2: well_formed ψ2
wfp: well_formed p
wfq: well_formed q
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]]
using i
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]]
using i
Hwf1: well_formed ψ1^[[evar:E↦p]] = true
HeqHwf1: Hwf1 =
well_formed_free_evar_subst_0 E ψ1 p wfp
  wfψ1
Hwf2: well_formed ψ1^[[evar:E↦q]] = true
HeqHwf2: Hwf2 =
well_formed_free_evar_subst_0 E ψ1 q wfq
  wfψ1
Hwf3: well_formed ψ2^[[evar:E↦p]] = true
HeqHwf3: Hwf3 =
well_formed_free_evar_subst_0 E ψ2 p wfp
  wfψ2
Hwf4: well_formed ψ2^[[evar:E↦q]] = true
HeqHwf4: Hwf4 =
well_formed_free_evar_subst_0 E ψ2 q wfq
  wfψ2
well_formed (ψ1^[[evar:E↦p]] ---> ψ1^[[evar:E↦q]])
Σ: Signature
Γ: Theory
ψ1, ψ2, p, q: Pattern
E: evar
i: ProofInfo
wfψ1: well_formed ψ1
wfψ2: well_formed ψ2
wfp: well_formed p
wfq: well_formed q
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]]
using i
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]]
using i
Hwf1: well_formed ψ1^[[evar:E↦p]] = true
HeqHwf1: Hwf1 =
well_formed_free_evar_subst_0 E ψ1 p wfp
  wfψ1
Hwf2: well_formed ψ1^[[evar:E↦q]] = true
HeqHwf2: Hwf2 =
well_formed_free_evar_subst_0 E ψ1 q wfq
  wfψ1
Hwf3: well_formed ψ2^[[evar:E↦p]] = true
HeqHwf3: Hwf3 =
well_formed_free_evar_subst_0 E ψ2 p wfp
  wfψ2
Hwf4: well_formed ψ2^[[evar:E↦q]] = true
HeqHwf4: Hwf4 =
well_formed_free_evar_subst_0 E ψ2 q wfq
  wfψ2
well_formed (ψ1^[[evar:E↦q]] ---> ψ1^[[evar:E↦p]])
          apply pf₁.
Σ: Signature
Γ: Theory
ψ1, ψ2, p, q: Pattern
E: evar
i: ProofInfo
wfψ1: well_formed ψ1
wfψ2: well_formed ψ2
wfp: well_formed p
wfq: well_formed q
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]]
using i
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]]
using i
Hwf1: well_formed ψ1^[[evar:E↦p]] = true
HeqHwf1: Hwf1 =
well_formed_free_evar_subst_0 E ψ1 p wfp
  wfψ1
Hwf2: well_formed ψ1^[[evar:E↦q]] = true
HeqHwf2: Hwf2 =
well_formed_free_evar_subst_0 E ψ1 q wfq
  wfψ1
Hwf3: well_formed ψ2^[[evar:E↦p]] = true
HeqHwf3: Hwf3 =
well_formed_free_evar_subst_0 E ψ2 p wfp
  wfψ2
Hwf4: well_formed ψ2^[[evar:E↦q]] = true
HeqHwf4: Hwf4 =
well_formed_free_evar_subst_0 E ψ2 q wfq
  wfψ2
well_formed (ψ1^[[evar:E↦p]] ---> ψ1^[[evar:E↦q]])
Σ: Signature
Γ: Theory
ψ1, ψ2, p, q: Pattern
E: evar
i: ProofInfo
wfψ1: well_formed ψ1
wfψ2: well_formed ψ2
wfp: well_formed p
wfq: well_formed q
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]]
using i
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]]
using i
Hwf1: well_formed ψ1^[[evar:E↦p]] = true
HeqHwf1: Hwf1 =
well_formed_free_evar_subst_0 E ψ1 p wfp
  wfψ1
Hwf2: well_formed ψ1^[[evar:E↦q]] = true
HeqHwf2: Hwf2 =
well_formed_free_evar_subst_0 E ψ1 q wfq
  wfψ1
Hwf3: well_formed ψ2^[[evar:E↦p]] = true
HeqHwf3: Hwf3 =
well_formed_free_evar_subst_0 E ψ2 p wfp
  wfψ2
Hwf4: well_formed ψ2^[[evar:E↦q]] = true
HeqHwf4: Hwf4 =
well_formed_free_evar_subst_0 E ψ2 q wfq
  wfψ2
well_formed (ψ1^[[evar:E↦q]] ---> ψ1^[[evar:E↦p]])
          {
Σ: Signature
Γ: Theory
ψ1, ψ2, p, q: Pattern
E: evar
i: ProofInfo
wfψ1: well_formed ψ1
wfψ2: well_formed ψ2
wfp: well_formed p
wfq: well_formed q
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]]
using i
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]]
using i
Hwf1: well_formed ψ1^[[evar:E↦p]] = true
HeqHwf1: Hwf1 =
well_formed_free_evar_subst_0 E ψ1 p wfp
  wfψ1
Hwf2: well_formed ψ1^[[evar:E↦q]] = true
HeqHwf2: Hwf2 =
well_formed_free_evar_subst_0 E ψ1 q wfq
  wfψ1
Hwf3: well_formed ψ2^[[evar:E↦p]] = true
HeqHwf3: Hwf3 =
well_formed_free_evar_subst_0 E ψ2 p wfp
  wfψ2
Hwf4: well_formed ψ2^[[evar:E↦q]] = true
HeqHwf4: Hwf4 =
well_formed_free_evar_subst_0 E ψ2 q wfq
  wfψ2
well_formed (ψ1^[[evar:E↦p]] ---> ψ1^[[evar:E↦q]]) abstract (wf_auto2). }
Σ: Signature
Γ: Theory
ψ1, ψ2, p, q: Pattern
E: evar
i: ProofInfo
wfψ1: well_formed ψ1
wfψ2: well_formed ψ2
wfp: well_formed p
wfq: well_formed q
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]]
using i
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]]
using i
Hwf1: well_formed ψ1^[[evar:E↦p]] = true
HeqHwf1: Hwf1 =
well_formed_free_evar_subst_0 E ψ1 p wfp
  wfψ1
Hwf2: well_formed ψ1^[[evar:E↦q]] = true
HeqHwf2: Hwf2 =
well_formed_free_evar_subst_0 E ψ1 q wfq
  wfψ1
Hwf3: well_formed ψ2^[[evar:E↦p]] = true
HeqHwf3: Hwf3 =
well_formed_free_evar_subst_0 E ψ2 p wfp
  wfψ2
Hwf4: well_formed ψ2^[[evar:E↦q]] = true
HeqHwf4: Hwf4 =
well_formed_free_evar_subst_0 E ψ2 q wfq
  wfψ2
well_formed (ψ1^[[evar:E↦q]] ---> ψ1^[[evar:E↦p]])
          {
Σ: Signature
Γ: Theory
ψ1, ψ2, p, q: Pattern
E: evar
i: ProofInfo
wfψ1: well_formed ψ1
wfψ2: well_formed ψ2
wfp: well_formed p
wfq: well_formed q
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]]
using i
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]]
using i
Hwf1: well_formed ψ1^[[evar:E↦p]] = true
HeqHwf1: Hwf1 =
well_formed_free_evar_subst_0 E ψ1 p wfp
  wfψ1
Hwf2: well_formed ψ1^[[evar:E↦q]] = true
HeqHwf2: Hwf2 =
well_formed_free_evar_subst_0 E ψ1 q wfq
  wfψ1
Hwf3: well_formed ψ2^[[evar:E↦p]] = true
HeqHwf3: Hwf3 =
well_formed_free_evar_subst_0 E ψ2 p wfp
  wfψ2
Hwf4: well_formed ψ2^[[evar:E↦q]] = true
HeqHwf4: Hwf4 =
well_formed_free_evar_subst_0 E ψ2 q wfq
  wfψ2
well_formed (ψ1^[[evar:E↦q]] ---> ψ1^[[evar:E↦p]]) abstract (wf_auto2). }
        }
      }
Σ: Signature
Γ: Theory
ψ1, ψ2, p, q: Pattern
E: evar
i: ProofInfo
wfψ1: well_formed ψ1
wfψ2: well_formed ψ2
wfp: well_formed p
wfq: well_formed q
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]]
using i
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]]
using i
Hwf1: well_formed ψ1^[[evar:E↦p]] = true
HeqHwf1: Hwf1 =
well_formed_free_evar_subst_0 E ψ1 p wfp
  wfψ1
Hwf2: well_formed ψ1^[[evar:E↦q]] = true
HeqHwf2: Hwf2 =
well_formed_free_evar_subst_0 E ψ1 q wfq
  wfψ1
Hwf3: well_formed ψ2^[[evar:E↦p]] = true
HeqHwf3: Hwf3 =
well_formed_free_evar_subst_0 E ψ2 p wfp
  wfψ2
Hwf4: well_formed ψ2^[[evar:E↦q]] = true
HeqHwf4: Hwf4 =
well_formed_free_evar_subst_0 E ψ2 q wfq
  wfψ2
well_formed
  (ψ1^[[evar:E↦p]] $ ψ2^[[evar:E↦p]] --->
   ψ1^[[evar:E↦q]] $ ψ2^[[evar:E↦p]])
Σ: Signature
Γ: Theory
ψ1, ψ2, p, q: Pattern
E: evar
i: ProofInfo
wfψ1: well_formed ψ1
wfψ2: well_formed ψ2
wfp: well_formed p
wfq: well_formed q
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]]
using i
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]]
using i
Hwf1: well_formed ψ1^[[evar:E↦p]] = true
HeqHwf1: Hwf1 =
well_formed_free_evar_subst_0 E ψ1 p wfp
  wfψ1
Hwf2: well_formed ψ1^[[evar:E↦q]] = true
HeqHwf2: Hwf2 =
well_formed_free_evar_subst_0 E ψ1 q wfq
  wfψ1
Hwf3: well_formed ψ2^[[evar:E↦p]] = true
HeqHwf3: Hwf3 =
well_formed_free_evar_subst_0 E ψ2 p wfp
  wfψ2
Hwf4: well_formed ψ2^[[evar:E↦q]] = true
HeqHwf4: Hwf4 =
well_formed_free_evar_subst_0 E ψ2 q wfq
  wfψ2
well_formed
  (ψ1^[[evar:E↦q]] $ ψ2^[[evar:E↦p]] --->
   ψ1^[[evar:E↦p]] $ ψ2^[[evar:E↦p]])
      {
Σ: Signature
Γ: Theory
ψ1, ψ2, p, q: Pattern
E: evar
i: ProofInfo
wfψ1: well_formed ψ1
wfψ2: well_formed ψ2
wfp: well_formed p
wfq: well_formed q
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]]
using i
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]]
using i
Hwf1: well_formed ψ1^[[evar:E↦p]] = true
HeqHwf1: Hwf1 =
well_formed_free_evar_subst_0 E ψ1 p wfp
  wfψ1
Hwf2: well_formed ψ1^[[evar:E↦q]] = true
HeqHwf2: Hwf2 =
well_formed_free_evar_subst_0 E ψ1 q wfq
  wfψ1
Hwf3: well_formed ψ2^[[evar:E↦p]] = true
HeqHwf3: Hwf3 =
well_formed_free_evar_subst_0 E ψ2 p wfp
  wfψ2
Hwf4: well_formed ψ2^[[evar:E↦q]] = true
HeqHwf4: Hwf4 =
well_formed_free_evar_subst_0 E ψ2 q wfq
  wfψ2
well_formed
  (ψ1^[[evar:E↦p]] $ ψ2^[[evar:E↦p]] --->
   ψ1^[[evar:E↦q]] $ ψ2^[[evar:E↦p]])
        abstract (wf_auto2).
      }
Σ: Signature
Γ: Theory
ψ1, ψ2, p, q: Pattern
E: evar
i: ProofInfo
wfψ1: well_formed ψ1
wfψ2: well_formed ψ2
wfp: well_formed p
wfq: well_formed q
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]]
using i
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]]
using i
Hwf1: well_formed ψ1^[[evar:E↦p]] = true
HeqHwf1: Hwf1 =
well_formed_free_evar_subst_0 E ψ1 p wfp
  wfψ1
Hwf2: well_formed ψ1^[[evar:E↦q]] = true
HeqHwf2: Hwf2 =
well_formed_free_evar_subst_0 E ψ1 q wfq
  wfψ1
Hwf3: well_formed ψ2^[[evar:E↦p]] = true
HeqHwf3: Hwf3 =
well_formed_free_evar_subst_0 E ψ2 p wfp
  wfψ2
Hwf4: well_formed ψ2^[[evar:E↦q]] = true
HeqHwf4: Hwf4 =
well_formed_free_evar_subst_0 E ψ2 q wfq
  wfψ2
well_formed
  (ψ1^[[evar:E↦q]] $ ψ2^[[evar:E↦p]] --->
   ψ1^[[evar:E↦p]] $ ψ2^[[evar:E↦p]])
      {
Σ: Signature
Γ: Theory
ψ1, ψ2, p, q: Pattern
E: evar
i: ProofInfo
wfψ1: well_formed ψ1
wfψ2: well_formed ψ2
wfp: well_formed p
wfq: well_formed q
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]]
using i
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]]
using i
Hwf1: well_formed ψ1^[[evar:E↦p]] = true
HeqHwf1: Hwf1 =
well_formed_free_evar_subst_0 E ψ1 p wfp
  wfψ1
Hwf2: well_formed ψ1^[[evar:E↦q]] = true
HeqHwf2: Hwf2 =
well_formed_free_evar_subst_0 E ψ1 q wfq
  wfψ1
Hwf3: well_formed ψ2^[[evar:E↦p]] = true
HeqHwf3: Hwf3 =
well_formed_free_evar_subst_0 E ψ2 p wfp
  wfψ2
Hwf4: well_formed ψ2^[[evar:E↦q]] = true
HeqHwf4: Hwf4 =
well_formed_free_evar_subst_0 E ψ2 q wfq
  wfψ2
well_formed
  (ψ1^[[evar:E↦q]] $ ψ2^[[evar:E↦p]] --->
   ψ1^[[evar:E↦p]] $ ψ2^[[evar:E↦p]])
        abstract (wf_auto2).
      }
    }
Σ: Signature
Γ: Theory
ψ1, ψ2, p, q: Pattern
E: evar
i: ProofInfo
wfψ1: well_formed ψ1
wfψ2: well_formed ψ2
wfp: well_formed p
wfq: well_formed q
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]]
using i
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]]
using i
Hwf1: well_formed ψ1^[[evar:E↦p]] = true
HeqHwf1: Hwf1 =
well_formed_free_evar_subst_0 E ψ1 p wfp
  wfψ1
Hwf2: well_formed ψ1^[[evar:E↦q]] = true
HeqHwf2: Hwf2 =
well_formed_free_evar_subst_0 E ψ1 q wfq
  wfψ1
Hwf3: well_formed ψ2^[[evar:E↦p]] = true
HeqHwf3: Hwf3 =
well_formed_free_evar_subst_0 E ψ2 p wfp
  wfψ2
Hwf4: well_formed ψ2^[[evar:E↦q]] = true
HeqHwf4: Hwf4 =
well_formed_free_evar_subst_0 E ψ2 q wfq
  wfψ2
well_formed (ψ1^[[evar:E↦p]] $ ψ2^[[evar:E↦p]])
Σ: Signature
Γ: Theory
ψ1, ψ2, p, q: Pattern
E: evar
i: ProofInfo
wfψ1: well_formed ψ1
wfψ2: well_formed ψ2
wfp: well_formed p
wfq: well_formed q
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]]
using i
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]]
using i
Hwf1: well_formed ψ1^[[evar:E↦p]] = true
HeqHwf1: Hwf1 =
well_formed_free_evar_subst_0 E ψ1 p wfp
  wfψ1
Hwf2: well_formed ψ1^[[evar:E↦q]] = true
HeqHwf2: Hwf2 =
well_formed_free_evar_subst_0 E ψ1 q wfq
  wfψ1
Hwf3: well_formed ψ2^[[evar:E↦p]] = true
HeqHwf3: Hwf3 =
well_formed_free_evar_subst_0 E ψ2 p wfp
  wfψ2
Hwf4: well_formed ψ2^[[evar:E↦q]] = true
HeqHwf4: Hwf4 =
well_formed_free_evar_subst_0 E ψ2 q wfq
  wfψ2
well_formed (ψ1^[[evar:E↦q]] $ ψ2^[[evar:E↦p]])
Σ: Signature
Γ: Theory
ψ1, ψ2, p, q: Pattern
E: evar
i: ProofInfo
wfψ1: well_formed ψ1
wfψ2: well_formed ψ2
wfp: well_formed p
wfq: well_formed q
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]]
using i
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]]
using i
Hwf1: well_formed ψ1^[[evar:E↦p]] = true
HeqHwf1: Hwf1 =
well_formed_free_evar_subst_0 E ψ1 p wfp
  wfψ1
Hwf2: well_formed ψ1^[[evar:E↦q]] = true
HeqHwf2: Hwf2 =
well_formed_free_evar_subst_0 E ψ1 q wfq
  wfψ1
Hwf3: well_formed ψ2^[[evar:E↦p]] = true
HeqHwf3: Hwf3 =
well_formed_free_evar_subst_0 E ψ2 p wfp
  wfψ2
Hwf4: well_formed ψ2^[[evar:E↦q]] = true
HeqHwf4: Hwf4 =
well_formed_free_evar_subst_0 E ψ2 q wfq
  wfψ2
well_formed (ψ1^[[evar:E↦q]] $ ψ2^[[evar:E↦q]])
    {
Σ: Signature
Γ: Theory
ψ1, ψ2, p, q: Pattern
E: evar
i: ProofInfo
wfψ1: well_formed ψ1
wfψ2: well_formed ψ2
wfp: well_formed p
wfq: well_formed q
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]]
using i
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]]
using i
Hwf1: well_formed ψ1^[[evar:E↦p]] = true
HeqHwf1: Hwf1 =
well_formed_free_evar_subst_0 E ψ1 p wfp
  wfψ1
Hwf2: well_formed ψ1^[[evar:E↦q]] = true
HeqHwf2: Hwf2 =
well_formed_free_evar_subst_0 E ψ1 q wfq
  wfψ1
Hwf3: well_formed ψ2^[[evar:E↦p]] = true
HeqHwf3: Hwf3 =
well_formed_free_evar_subst_0 E ψ2 p wfp
  wfψ2
Hwf4: well_formed ψ2^[[evar:E↦q]] = true
HeqHwf4: Hwf4 =
well_formed_free_evar_subst_0 E ψ2 q wfq
  wfψ2
well_formed (ψ1^[[evar:E↦p]] $ ψ2^[[evar:E↦p]]) abstract (wf_auto2). }
Σ: Signature
Γ: Theory
ψ1, ψ2, p, q: Pattern
E: evar
i: ProofInfo
wfψ1: well_formed ψ1
wfψ2: well_formed ψ2
wfp: well_formed p
wfq: well_formed q
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]]
using i
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]]
using i
Hwf1: well_formed ψ1^[[evar:E↦p]] = true
HeqHwf1: Hwf1 =
well_formed_free_evar_subst_0 E ψ1 p wfp
  wfψ1
Hwf2: well_formed ψ1^[[evar:E↦q]] = true
HeqHwf2: Hwf2 =
well_formed_free_evar_subst_0 E ψ1 q wfq
  wfψ1
Hwf3: well_formed ψ2^[[evar:E↦p]] = true
HeqHwf3: Hwf3 =
well_formed_free_evar_subst_0 E ψ2 p wfp
  wfψ2
Hwf4: well_formed ψ2^[[evar:E↦q]] = true
HeqHwf4: Hwf4 =
well_formed_free_evar_subst_0 E ψ2 q wfq
  wfψ2
well_formed (ψ1^[[evar:E↦q]] $ ψ2^[[evar:E↦p]])
Σ: Signature
Γ: Theory
ψ1, ψ2, p, q: Pattern
E: evar
i: ProofInfo
wfψ1: well_formed ψ1
wfψ2: well_formed ψ2
wfp: well_formed p
wfq: well_formed q
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]]
using i
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]]
using i
Hwf1: well_formed ψ1^[[evar:E↦p]] = true
HeqHwf1: Hwf1 =
well_formed_free_evar_subst_0 E ψ1 p wfp
  wfψ1
Hwf2: well_formed ψ1^[[evar:E↦q]] = true
HeqHwf2: Hwf2 =
well_formed_free_evar_subst_0 E ψ1 q wfq
  wfψ1
Hwf3: well_formed ψ2^[[evar:E↦p]] = true
HeqHwf3: Hwf3 =
well_formed_free_evar_subst_0 E ψ2 p wfp
  wfψ2
Hwf4: well_formed ψ2^[[evar:E↦q]] = true
HeqHwf4: Hwf4 =
well_formed_free_evar_subst_0 E ψ2 q wfq
  wfψ2
well_formed (ψ1^[[evar:E↦q]] $ ψ2^[[evar:E↦q]])
    {
Σ: Signature
Γ: Theory
ψ1, ψ2, p, q: Pattern
E: evar
i: ProofInfo
wfψ1: well_formed ψ1
wfψ2: well_formed ψ2
wfp: well_formed p
wfq: well_formed q
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]]
using i
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]]
using i
Hwf1: well_formed ψ1^[[evar:E↦p]] = true
HeqHwf1: Hwf1 =
well_formed_free_evar_subst_0 E ψ1 p wfp
  wfψ1
Hwf2: well_formed ψ1^[[evar:E↦q]] = true
HeqHwf2: Hwf2 =
well_formed_free_evar_subst_0 E ψ1 q wfq
  wfψ1
Hwf3: well_formed ψ2^[[evar:E↦p]] = true
HeqHwf3: Hwf3 =
well_formed_free_evar_subst_0 E ψ2 p wfp
  wfψ2
Hwf4: well_formed ψ2^[[evar:E↦q]] = true
HeqHwf4: Hwf4 =
well_formed_free_evar_subst_0 E ψ2 q wfq
  wfψ2
well_formed (ψ1^[[evar:E↦q]] $ ψ2^[[evar:E↦p]]) abstract (wf_auto2). }
Σ: Signature
Γ: Theory
ψ1, ψ2, p, q: Pattern
E: evar
i: ProofInfo
wfψ1: well_formed ψ1
wfψ2: well_formed ψ2
wfp: well_formed p
wfq: well_formed q
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]]
using i
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]]
using i
Hwf1: well_formed ψ1^[[evar:E↦p]] = true
HeqHwf1: Hwf1 =
well_formed_free_evar_subst_0 E ψ1 p wfp
  wfψ1
Hwf2: well_formed ψ1^[[evar:E↦q]] = true
HeqHwf2: Hwf2 =
well_formed_free_evar_subst_0 E ψ1 q wfq
  wfψ1
Hwf3: well_formed ψ2^[[evar:E↦p]] = true
HeqHwf3: Hwf3 =
well_formed_free_evar_subst_0 E ψ2 p wfp
  wfψ2
Hwf4: well_formed ψ2^[[evar:E↦q]] = true
HeqHwf4: Hwf4 =
well_formed_free_evar_subst_0 E ψ2 q wfq
  wfψ2
well_formed (ψ1^[[evar:E↦q]] $ ψ2^[[evar:E↦q]])
    {
Σ: Signature
Γ: Theory
ψ1, ψ2, p, q: Pattern
E: evar
i: ProofInfo
wfψ1: well_formed ψ1
wfψ2: well_formed ψ2
wfp: well_formed p
wfq: well_formed q
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]]
using i
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]]
using i
Hwf1: well_formed ψ1^[[evar:E↦p]] = true
HeqHwf1: Hwf1 =
well_formed_free_evar_subst_0 E ψ1 p wfp
  wfψ1
Hwf2: well_formed ψ1^[[evar:E↦q]] = true
HeqHwf2: Hwf2 =
well_formed_free_evar_subst_0 E ψ1 q wfq
  wfψ1
Hwf3: well_formed ψ2^[[evar:E↦p]] = true
HeqHwf3: Hwf3 =
well_formed_free_evar_subst_0 E ψ2 p wfp
  wfψ2
Hwf4: well_formed ψ2^[[evar:E↦q]] = true
HeqHwf4: Hwf4 =
well_formed_free_evar_subst_0 E ψ2 q wfq
  wfψ2
well_formed (ψ1^[[evar:E↦q]] $ ψ2^[[evar:E↦q]]) abstract (wf_auto2). }
  Defined.

  Lemma count_evar_occurrences_evar_replace φ x y :
    x ∉ free_evars φ ->
    count_evar_occurrences x φ^[[evar:y↦patt_free_evar x]] =
    count_evar_occurrences y φ.
Σ: Signature
φ: Pattern
x, y: evar
x ∉ free_evars φ
→ count_evar_occurrences x
    φ^[[evar:y↦patt_free_evar x]] =
  count_evar_occurrences y φ
  Proof.
Σ: Signature
φ: Pattern
x, y: evar
x ∉ free_evars φ
→ count_evar_occurrences x
    φ^[[evar:y↦patt_free_evar x]] =
  count_evar_occurrences y φ
    induction φ; intro H; simpl in *; auto.
Σ: Signature
x0, x, y: evar
H: x ∉ {[x0]}
count_evar_occurrences x
  (if decide (y = x0)
   then patt_free_evar x
   else patt_free_evar x0) =
(if decide (x0 = y) then 1 else 0)
Σ: Signature
φ1, φ2: Pattern
x, y: evar
IHφ1: x ∉ free_evars φ1
→ count_evar_occurrences x
    φ1^[[evar:y↦patt_free_evar x]] =
  count_evar_occurrences y φ1
IHφ2: x ∉ free_evars φ2
→ count_evar_occurrences x
    φ2^[[evar:y↦patt_free_evar x]] =
  count_evar_occurrences y φ2
H: x ∉ free_evars φ1 ∪ free_evars φ2
count_evar_occurrences x
  φ1^[[evar:y↦patt_free_evar x]] +
count_evar_occurrences x
  φ2^[[evar:y↦patt_free_evar x]] =
count_evar_occurrences y φ1 +
count_evar_occurrences y φ2
Σ: Signature
φ1, φ2: Pattern
x, y: evar
IHφ1: x ∉ free_evars φ1
→ count_evar_occurrences x
    φ1^[[evar:y↦patt_free_evar x]] =
  count_evar_occurrences y φ1
IHφ2: x ∉ free_evars φ2
→ count_evar_occurrences x
    φ2^[[evar:y↦patt_free_evar x]] =
  count_evar_occurrences y φ2
H: x ∉ free_evars φ1 ∪ free_evars φ2
count_evar_occurrences x
  φ1^[[evar:y↦patt_free_evar x]] +
count_evar_occurrences x
  φ2^[[evar:y↦patt_free_evar x]] =
count_evar_occurrences y φ1 +
count_evar_occurrences y φ2
    *
Σ: Signature
x0, x, y: evar
H: x ∉ {[x0]}
count_evar_occurrences x
  (if decide (y = x0)
   then patt_free_evar x
   else patt_free_evar x0) =
(if decide (x0 = y) then 1 else 0) do 2 destruct decide; simpl; case_match; auto; try contradiction; set_solver.
    *
Σ: Signature
φ1, φ2: Pattern
x, y: evar
IHφ1: x ∉ free_evars φ1
→ count_evar_occurrences x
    φ1^[[evar:y↦patt_free_evar x]] =
  count_evar_occurrences y φ1
IHφ2: x ∉ free_evars φ2
→ count_evar_occurrences x
    φ2^[[evar:y↦patt_free_evar x]] =
  count_evar_occurrences y φ2
H: x ∉ free_evars φ1 ∪ free_evars φ2
count_evar_occurrences x
  φ1^[[evar:y↦patt_free_evar x]] +
count_evar_occurrences x
  φ2^[[evar:y↦patt_free_evar x]] =
count_evar_occurrences y φ1 +
count_evar_occurrences y φ2 rewrite IHφ1.
Σ: Signature
φ1, φ2: Pattern
x, y: evar
IHφ1: x ∉ free_evars φ1
→ count_evar_occurrences x
    φ1^[[evar:y↦patt_free_evar x]] =
  count_evar_occurrences y φ1
IHφ2: x ∉ free_evars φ2
→ count_evar_occurrences x
    φ2^[[evar:y↦patt_free_evar x]] =
  count_evar_occurrences y φ2
H: x ∉ free_evars φ1 ∪ free_evars φ2
x ∉ free_evars φ1
Σ: Signature
φ1, φ2: Pattern
x, y: evar
IHφ1: x ∉ free_evars φ1
→ count_evar_occurrences x
    φ1^[[evar:y↦patt_free_evar x]] =
  count_evar_occurrences y φ1
IHφ2: x ∉ free_evars φ2
→ count_evar_occurrences x
    φ2^[[evar:y↦patt_free_evar x]] =
  count_evar_occurrences y φ2
H: x ∉ free_evars φ1 ∪ free_evars φ2
count_evar_occurrences y φ1 +
count_evar_occurrences x
  φ2^[[evar:y↦patt_free_evar x]] =
count_evar_occurrences y φ1 +
count_evar_occurrences y φ2 2: rewrite IHφ2.
Σ: Signature
φ1, φ2: Pattern
x, y: evar
IHφ1: x ∉ free_evars φ1
→ count_evar_occurrences x
    φ1^[[evar:y↦patt_free_evar x]] =
  count_evar_occurrences y φ1
IHφ2: x ∉ free_evars φ2
→ count_evar_occurrences x
    φ2^[[evar:y↦patt_free_evar x]] =
  count_evar_occurrences y φ2
H: x ∉ free_evars φ1 ∪ free_evars φ2
x ∉ free_evars φ1
Σ: Signature
φ1, φ2: Pattern
x, y: evar
IHφ1: x ∉ free_evars φ1
→ count_evar_occurrences x
    φ1^[[evar:y↦patt_free_evar x]] =
  count_evar_occurrences y φ1
IHφ2: x ∉ free_evars φ2
→ count_evar_occurrences x
    φ2^[[evar:y↦patt_free_evar x]] =
  count_evar_occurrences y φ2
H: x ∉ free_evars φ1 ∪ free_evars φ2
x ∉ free_evars φ2
Σ: Signature
φ1, φ2: Pattern
x, y: evar
IHφ1: x ∉ free_evars φ1
→ count_evar_occurrences x
    φ1^[[evar:y↦patt_free_evar x]] =
  count_evar_occurrences y φ1
IHφ2: x ∉ free_evars φ2
→ count_evar_occurrences x
    φ2^[[evar:y↦patt_free_evar x]] =
  count_evar_occurrences y φ2
H: x ∉ free_evars φ1 ∪ free_evars φ2
count_evar_occurrences y φ1 +
count_evar_occurrences y φ2 =
count_evar_occurrences y φ1 +
count_evar_occurrences y φ2 all: set_solver.
    *
Σ: Signature
φ1, φ2: Pattern
x, y: evar
IHφ1: x ∉ free_evars φ1
→ count_evar_occurrences x
    φ1^[[evar:y↦patt_free_evar x]] =
  count_evar_occurrences y φ1
IHφ2: x ∉ free_evars φ2
→ count_evar_occurrences x
    φ2^[[evar:y↦patt_free_evar x]] =
  count_evar_occurrences y φ2
H: x ∉ free_evars φ1 ∪ free_evars φ2
count_evar_occurrences x
  φ1^[[evar:y↦patt_free_evar x]] +
count_evar_occurrences x
  φ2^[[evar:y↦patt_free_evar x]] =
count_evar_occurrences y φ1 +
count_evar_occurrences y φ2 rewrite IHφ1.
Σ: Signature
φ1, φ2: Pattern
x, y: evar
IHφ1: x ∉ free_evars φ1
→ count_evar_occurrences x
    φ1^[[evar:y↦patt_free_evar x]] =
  count_evar_occurrences y φ1
IHφ2: x ∉ free_evars φ2
→ count_evar_occurrences x
    φ2^[[evar:y↦patt_free_evar x]] =
  count_evar_occurrences y φ2
H: x ∉ free_evars φ1 ∪ free_evars φ2
x ∉ free_evars φ1
Σ: Signature
φ1, φ2: Pattern
x, y: evar
IHφ1: x ∉ free_evars φ1
→ count_evar_occurrences x
    φ1^[[evar:y↦patt_free_evar x]] =
  count_evar_occurrences y φ1
IHφ2: x ∉ free_evars φ2
→ count_evar_occurrences x
    φ2^[[evar:y↦patt_free_evar x]] =
  count_evar_occurrences y φ2
H: x ∉ free_evars φ1 ∪ free_evars φ2
count_evar_occurrences y φ1 +
count_evar_occurrences x
  φ2^[[evar:y↦patt_free_evar x]] =
count_evar_occurrences y φ1 +
count_evar_occurrences y φ2 2: rewrite IHφ2.
Σ: Signature
φ1, φ2: Pattern
x, y: evar
IHφ1: x ∉ free_evars φ1
→ count_evar_occurrences x
    φ1^[[evar:y↦patt_free_evar x]] =
  count_evar_occurrences y φ1
IHφ2: x ∉ free_evars φ2
→ count_evar_occurrences x
    φ2^[[evar:y↦patt_free_evar x]] =
  count_evar_occurrences y φ2
H: x ∉ free_evars φ1 ∪ free_evars φ2
x ∉ free_evars φ1
Σ: Signature
φ1, φ2: Pattern
x, y: evar
IHφ1: x ∉ free_evars φ1
→ count_evar_occurrences x
    φ1^[[evar:y↦patt_free_evar x]] =
  count_evar_occurrences y φ1
IHφ2: x ∉ free_evars φ2
→ count_evar_occurrences x
    φ2^[[evar:y↦patt_free_evar x]] =
  count_evar_occurrences y φ2
H: x ∉ free_evars φ1 ∪ free_evars φ2
x ∉ free_evars φ2
Σ: Signature
φ1, φ2: Pattern
x, y: evar
IHφ1: x ∉ free_evars φ1
→ count_evar_occurrences x
    φ1^[[evar:y↦patt_free_evar x]] =
  count_evar_occurrences y φ1
IHφ2: x ∉ free_evars φ2
→ count_evar_occurrences x
    φ2^[[evar:y↦patt_free_evar x]] =
  count_evar_occurrences y φ2
H: x ∉ free_evars φ1 ∪ free_evars φ2
count_evar_occurrences y φ1 +
count_evar_occurrences y φ2 =
count_evar_occurrences y φ1 +
count_evar_occurrences y φ2 all: set_solver.
  Qed.


  Definition mu_in_evar_path E ψ sdepth := negb (Nat.eqb 0 (maximal_mu_depth_to sdepth E ψ)).

  Lemma eq_prf_equiv_congruence
    (sz : nat)
    Γ p q evs svs
    (wfp : well_formed p)
    (wfq : well_formed q)
    E ψ edepth sdepth
    (Hsz: size' ψ <= sz)
    (wfψ : well_formed ψ)
    (gpi : ProofInfo)
    (** We need to do a number of Ex_Gen (and Substitution) steps
        in the proof, thus we need at least as many fresh variables
        as ∃-s (and μ-s) are in ψ. These should also be included in gpi.

        Actually, we do not need that many variables always, then
        depth of ∃-s should only be considered in the paths where
        E is present. For simplicity (and the fact that we have 
        infinitely many fresh variables), we chose not to use that
        approach
    *)
    el
    (Hel1 : fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}))
    (Hel2 : length el ≥ maximal_exists_depth_to edepth E ψ)
    (Hel3 : forall x, x ∈ el -> x ∈ evs)
    sl
    (Hsl1 : fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q))
    (Hsl2 : length sl ≥ maximal_mu_depth_to sdepth E ψ)
    (Hsl3 : forall X, X ∈ sl -> X ∈ svs)
    (pile: ProofInfoLe
           (ExGen := evs,
            SVSubst := svs,
            KT := mu_in_evar_path E ψ sdepth) gpi)
    (pf : Γ ⊢i (p <---> q) using ( gpi)) :
        Γ ⊢i (((ψ^[[evar: E ↦ p]]) <---> (ψ^[[evar: E ↦ q]]))) using ( gpi).
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
evs: coEVarSet
svs: coSVarSet
wfp: well_formed p
wfq: well_formed q
E: evar
ψ: Pattern
edepth, sdepth: nat
Hsz: size' ψ ≤ sz
wfψ: well_formed ψ
gpi: ProofInfo
el: list evar
Hel1: fresh_evars el
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs,
   KT := mu_in_evar_path E ψ sdepth) gpi
pf: Γ ⊢i p <---> q using gpi
Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
  Proof.
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
evs: coEVarSet
svs: coSVarSet
wfp: well_formed p
wfq: well_formed q
E: evar
ψ: Pattern
edepth, sdepth: nat
Hsz: size' ψ ≤ sz
wfψ: well_formed ψ
gpi: ProofInfo
el: list evar
Hel1: fresh_evars el
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs,
   KT := mu_in_evar_path E ψ sdepth) gpi
pf: Γ ⊢i p <---> q using gpi
Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
(* TODO: if there were a size function for coEVarSet/coSVarSet, then
         Hel3/Hsl3 would be not necessary *)
    move: edepth sdepth ψ wfψ Hsz evs svs gpi pile pf el Hel1 Hel2 Hel3 sl Hsl1 Hsl2 Hsl3.
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth) gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ ∪ free_svars p
                         ∪ free_svars q)
                      → length sl
                        ≥ maximal_mu_depth_to sdepth E
                            ψ
                        → (∀ X : svar,
                             X ∈ sl → X ∈ svs)
                          → Γ
                            ⊢i ψ^[[evar:E↦p]] <--->
                               ψ^[[evar:E↦q]]
                            using gpi
    induction sz; intros edepth sdepth ψ wfψ Hsz evs svs gpi pile pf el Hel1 Hel2 Hel3 sl Hsl1 Hsl2 Hsl3.
Σ: Signature
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed ψ
Hsz: size' ψ ≤ 0
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs,
   KT := mu_in_evar_path E ψ sdepth) gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                       (free_svars ψ
                       ∪ 
                       free_svars p
                       ∪ 
                       free_svars q)
                      → 
                      length sl
                      ≥ 
                      maximal_mu_depth_to
                       sdepth E ψ
                      → 
                      (∀ X : svar,
                       X ∈ sl → X ∈ svs)
                      → 
                      Γ
                      ⊢i 
                      ψ^[[evar:E↦p]] <--->
                      ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed ψ
Hsz: size' ψ ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs,
   KT := mu_in_evar_path E ψ sdepth) gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
    abstract (destruct ψ; simpl in Hsz; lia).
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed ψ
Hsz: size' ψ ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs,
   KT := mu_in_evar_path E ψ sdepth) gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi

    lazymatch type of pile with
    | ProofInfoLe ?st _ => set (i' := st) in *
    end.
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed ψ
Hsz: size' ψ ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E ψ sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi


  destruct (decide (E ∈ free_evars ψ)) as [HEinψ|HEnotinψ].
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed ψ
Hsz: size' ψ ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E ψ sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ
Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed ψ
Hsz: size' ψ ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E ψ sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEnotinψ: E ∉ free_evars ψ
Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
    2: {
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed ψ
Hsz: size' ψ ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E ψ sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEnotinψ: E ∉ free_evars ψ
Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi rewrite free_evar_subst_no_occurrence; auto.
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed ψ
Hsz: size' ψ ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E ψ sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEnotinψ: E ∉ free_evars ψ
Γ ⊢i ψ <---> ψ^[[evar:E↦q]] using gpi
      rewrite free_evar_subst_no_occurrence; auto.
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed ψ
Hsz: size' ψ ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E ψ sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEnotinψ: E ∉ free_evars ψ
Γ ⊢i ψ <---> ψ using gpi
      gapply pf_iff_equiv_refl.
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed ψ
Hsz: size' ψ ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E ψ sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEnotinψ: E ∉ free_evars ψ
ProofInfoLe BasicReasoning gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed ψ
Hsz: size' ψ ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E ψ sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEnotinψ: E ∉ free_evars ψ
well_formed ψ try_solve_pile.
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed ψ
Hsz: size' ψ ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E ψ sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEnotinψ: E ∉ free_evars ψ
well_formed ψ
      {
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed ψ
Hsz: size' ψ ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E ψ sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEnotinψ: E ∉ free_evars ψ
well_formed ψ abstract (wf_auto2). } }
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed ψ
Hsz: size' ψ ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E ψ sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ
Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi

    destruct ψ; simpl in Hsz; simpl.
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
x: evar
wfψ: well_formed (patt_free_evar x)
Hsz: 1 ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (patt_free_evar x) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars (patt_free_evar x) ∪ free_evars p
   ∪ free_evars q ∪ {[E]})
Hel2: length el
≥ maximal_exists_depth_to edepth E
    (patt_free_evar x)
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars (patt_free_evar x) ∪ free_svars p
   ∪ free_svars q)
Hsl2: length sl
≥ maximal_mu_depth_to sdepth E
    (patt_free_evar x)
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars (patt_free_evar x)
Γ
⊢i (if decide (E = x) then p else patt_free_evar x) <--->
   (if decide (E = x) then q else patt_free_evar x)
using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
x: svar
wfψ: well_formed (patt_free_svar x)
Hsz: 1 ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (patt_free_svar x) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars (patt_free_svar x) ∪ free_evars p
   ∪ free_evars q ∪ {[E]})
Hel2: length el
≥ maximal_exists_depth_to edepth E
    (patt_free_svar x)
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars (patt_free_svar x) ∪ free_svars p
   ∪ free_svars q)
Hsl2: length sl
≥ maximal_mu_depth_to sdepth E
    (patt_free_svar x)
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars (patt_free_svar x)
Γ ⊢i patt_free_svar x <---> patt_free_svar x using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
n: db_index
wfψ: well_formed (patt_bound_evar n)
Hsz: 1 ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (patt_bound_evar n) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars (patt_bound_evar n)
   ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el
≥ maximal_exists_depth_to edepth E
    (patt_bound_evar n)
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars (patt_bound_evar n)
   ∪ free_svars p ∪ free_svars q)
Hsl2: length sl
≥ maximal_mu_depth_to sdepth E
    (patt_bound_evar n)
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars (patt_bound_evar n)
Γ ⊢i patt_bound_evar n <---> patt_bound_evar n
using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
n: db_index
wfψ: well_formed (patt_bound_svar n)
Hsz: 1 ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (patt_bound_svar n) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars (patt_bound_svar n)
   ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el
≥ maximal_exists_depth_to edepth E
    (patt_bound_svar n)
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars (patt_bound_svar n)
   ∪ free_svars p ∪ free_svars q)
Hsl2: length sl
≥ maximal_mu_depth_to sdepth E
    (patt_bound_svar n)
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars (patt_bound_svar n)
Γ ⊢i patt_bound_svar n <---> patt_bound_svar n
using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
sigma: symbols
wfψ: well_formed (patt_sym sigma)
Hsz: 1 ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (patt_sym sigma) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars (patt_sym sigma) ∪ free_evars p
   ∪ free_evars q ∪ {[E]})
Hel2: length el
≥ maximal_exists_depth_to edepth E
    (patt_sym sigma)
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars (patt_sym sigma) ∪ free_svars p
   ∪ free_svars q)
Hsl2: length sl
≥ maximal_mu_depth_to sdepth E (patt_sym sigma)
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars (patt_sym sigma)
Γ ⊢i patt_sym sigma <---> patt_sym sigma using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ1, ψ2: Pattern
wfψ: well_formed (ψ1 $ ψ2)
Hsz: S (size' ψ1 + size' ψ2) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (ψ1 $ ψ2) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars (ψ1 $ ψ2) ∪ free_evars p
   ∪ free_evars q ∪ {[E]})
Hel2: length el
≥ maximal_exists_depth_to edepth E (ψ1 $ ψ2)
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars (ψ1 $ ψ2) ∪ free_svars p
   ∪ free_svars q)
Hsl2: length sl
≥ maximal_mu_depth_to sdepth E (ψ1 $ ψ2)
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars (ψ1 $ ψ2)
Γ
⊢i ψ1^[[evar:E↦p]] $ ψ2^[[evar:E↦p]] <--->
   ψ1^[[evar:E↦q]] $ ψ2^[[evar:E↦q]] using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
wfψ: well_formed ⊥
Hsz: 1 ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E ⊥ sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ⊥ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ⊥
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars ⊥ ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ⊥
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ⊥
Γ ⊢i ⊥ <---> ⊥ using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ1, ψ2: Pattern
wfψ: well_formed (ψ1 ---> ψ2)
Hsz: S (size' ψ1 + size' ψ2) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (ψ1 ---> ψ2) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars (ψ1 ---> ψ2) ∪ free_evars p
   ∪ free_evars q ∪ {[E]})
Hel2: length el
≥ maximal_exists_depth_to edepth E (ψ1 ---> ψ2)
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars (ψ1 ---> ψ2) ∪ free_svars p
   ∪ free_svars q)
Hsl2: length sl
≥ maximal_mu_depth_to sdepth E (ψ1 ---> ψ2)
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars (ψ1 ---> ψ2)
Γ
⊢i (ψ1^[[evar:E↦p]] ---> ψ2^[[evar:E↦p]]) <--->
   (ψ1^[[evar:E↦q]] ---> ψ2^[[evar:E↦q]]) using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (ex , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (ex , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars (ex , ψ) ∪ free_evars p
   ∪ free_evars q ∪ {[E]})
Hel2: length el
≥ maximal_exists_depth_to edepth E (ex , ψ)
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars (ex , ψ) ∪ free_svars p
   ∪ free_svars q)
Hsl2: length sl
≥ maximal_mu_depth_to sdepth E (ex , ψ)
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars (ex , ψ)
Γ ⊢i (ex , ψ^[[evar:E↦p]]) <---> (ex , ψ^[[evar:E↦q]])
using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (mu , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars (mu , ψ) ∪ free_evars p
   ∪ free_evars q ∪ {[E]})
Hel2: length el
≥ maximal_exists_depth_to edepth E (mu , ψ)
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars (mu , ψ) ∪ free_svars p
   ∪ free_svars q)
Hsl2: length sl
≥ maximal_mu_depth_to sdepth E (mu , ψ)
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars (mu , ψ)
Γ ⊢i (mu , ψ^[[evar:E↦p]]) <---> (mu , ψ^[[evar:E↦q]])
using gpi
    {
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
x: evar
wfψ: well_formed (patt_free_evar x)
Hsz: 1 ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (patt_free_evar x) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars (patt_free_evar x) ∪ free_evars p
   ∪ free_evars q ∪ {[E]})
Hel2: length el
≥ maximal_exists_depth_to edepth E
    (patt_free_evar x)
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars (patt_free_evar x) ∪ free_svars p
   ∪ free_svars q)
Hsl2: length sl
≥ maximal_mu_depth_to sdepth E
    (patt_free_evar x)
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars (patt_free_evar x)
Γ
⊢i (if decide (E = x) then p else patt_free_evar x) <--->
   (if decide (E = x) then q else patt_free_evar x)
using gpi
      destruct (decide (E = x)).
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
x: evar
wfψ: well_formed (patt_free_evar x)
Hsz: 1 ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (patt_free_evar x) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars (patt_free_evar x) ∪ free_evars p
   ∪ free_evars q ∪ {[E]})
Hel2: length el
≥ maximal_exists_depth_to edepth E
    (patt_free_evar x)
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars (patt_free_evar x) ∪ free_svars p
   ∪ free_svars q)
Hsl2: length sl
≥ maximal_mu_depth_to sdepth E
    (patt_free_evar x)
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars (patt_free_evar x)
e: E = x
Γ ⊢i p <---> q using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
x: evar
wfψ: well_formed (patt_free_evar x)
Hsz: 1 ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (patt_free_evar x) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars (patt_free_evar x) ∪ free_evars p
   ∪ free_evars q ∪ {[E]})
Hel2: length el
≥ maximal_exists_depth_to edepth E
    (patt_free_evar x)
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars (patt_free_evar x) ∪ free_svars p
   ∪ free_svars q)
Hsl2: length sl
≥ maximal_mu_depth_to sdepth E
    (patt_free_evar x)
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars (patt_free_evar x)
n: E ≠ x
Γ ⊢i patt_free_evar x <---> patt_free_evar x using gpi
      {
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
x: evar
wfψ: well_formed (patt_free_evar x)
Hsz: 1 ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (patt_free_evar x) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars (patt_free_evar x) ∪ free_evars p
   ∪ free_evars q ∪ {[E]})
Hel2: length el
≥ maximal_exists_depth_to edepth E
    (patt_free_evar x)
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars (patt_free_evar x) ∪ free_svars p
   ∪ free_svars q)
Hsl2: length sl
≥ maximal_mu_depth_to sdepth E
    (patt_free_evar x)
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars (patt_free_evar x)
e: E = x
Γ ⊢i p <---> q using gpi
        exact pf.
      }
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
x: evar
wfψ: well_formed (patt_free_evar x)
Hsz: 1 ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (patt_free_evar x) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars (patt_free_evar x) ∪ free_evars p
   ∪ free_evars q ∪ {[E]})
Hel2: length el
≥ maximal_exists_depth_to edepth E
    (patt_free_evar x)
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars (patt_free_evar x) ∪ free_svars p
   ∪ free_svars q)
Hsl2: length sl
≥ maximal_mu_depth_to sdepth E
    (patt_free_evar x)
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars (patt_free_evar x)
n: E ≠ x
Γ ⊢i patt_free_evar x <---> patt_free_evar x using gpi
      {
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
x: evar
wfψ: well_formed (patt_free_evar x)
Hsz: 1 ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (patt_free_evar x) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars (patt_free_evar x) ∪ free_evars p
   ∪ free_evars q ∪ {[E]})
Hel2: length el
≥ maximal_exists_depth_to edepth E
    (patt_free_evar x)
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars (patt_free_evar x) ∪ free_svars p
   ∪ free_svars q)
Hsl2: length sl
≥ maximal_mu_depth_to sdepth E
    (patt_free_evar x)
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars (patt_free_evar x)
n: E ≠ x
Γ ⊢i patt_free_evar x <---> patt_free_evar x using gpi
        useBasicReasoning.
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
x: evar
wfψ: well_formed (patt_free_evar x)
Hsz: 1 ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (patt_free_evar x) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars (patt_free_evar x) ∪ free_evars p
   ∪ free_evars q ∪ {[E]})
Hel2: length el
≥ maximal_exists_depth_to edepth E
    (patt_free_evar x)
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars (patt_free_evar x) ∪ free_svars p
   ∪ free_svars q)
Hsl2: length sl
≥ maximal_mu_depth_to sdepth E
    (patt_free_evar x)
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars (patt_free_evar x)
n: E ≠ x
Γ ⊢i patt_free_evar x <---> patt_free_evar x
using BasicReasoning
        apply pf_iff_equiv_refl.
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
x: evar
wfψ: well_formed (patt_free_evar x)
Hsz: 1 ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (patt_free_evar x) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars (patt_free_evar x) ∪ free_evars p
   ∪ free_evars q ∪ {[E]})
Hel2: length el
≥ maximal_exists_depth_to edepth E
    (patt_free_evar x)
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars (patt_free_evar x) ∪ free_svars p
   ∪ free_svars q)
Hsl2: length sl
≥ maximal_mu_depth_to sdepth E
    (patt_free_evar x)
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars (patt_free_evar x)
n: E ≠ x
well_formed (patt_free_evar x)
        abstract (wf_auto2).
      }
    }
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
x: svar
wfψ: well_formed (patt_free_svar x)
Hsz: 1 ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (patt_free_svar x) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars (patt_free_svar x) ∪ free_evars p
   ∪ free_evars q ∪ {[E]})
Hel2: length el
≥ maximal_exists_depth_to edepth E
    (patt_free_svar x)
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars (patt_free_svar x) ∪ free_svars p
   ∪ free_svars q)
Hsl2: length sl
≥ maximal_mu_depth_to sdepth E
    (patt_free_svar x)
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars (patt_free_svar x)
Γ ⊢i patt_free_svar x <---> patt_free_svar x using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
n: db_index
wfψ: well_formed (patt_bound_evar n)
Hsz: 1 ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (patt_bound_evar n) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars (patt_bound_evar n)
   ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el
≥ maximal_exists_depth_to edepth E
    (patt_bound_evar n)
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars (patt_bound_evar n)
   ∪ free_svars p ∪ free_svars q)
Hsl2: length sl
≥ maximal_mu_depth_to sdepth E
    (patt_bound_evar n)
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars (patt_bound_evar n)
Γ ⊢i patt_bound_evar n <---> patt_bound_evar n
using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
n: db_index
wfψ: well_formed (patt_bound_svar n)
Hsz: 1 ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (patt_bound_svar n) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars (patt_bound_svar n)
   ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el
≥ maximal_exists_depth_to edepth E
    (patt_bound_svar n)
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars (patt_bound_svar n)
   ∪ free_svars p ∪ free_svars q)
Hsl2: length sl
≥ maximal_mu_depth_to sdepth E
    (patt_bound_svar n)
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars (patt_bound_svar n)
Γ ⊢i patt_bound_svar n <---> patt_bound_svar n
using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
sigma: symbols
wfψ: well_formed (patt_sym sigma)
Hsz: 1 ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (patt_sym sigma) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars (patt_sym sigma) ∪ free_evars p
   ∪ free_evars q ∪ {[E]})
Hel2: length el
≥ maximal_exists_depth_to edepth E
    (patt_sym sigma)
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars (patt_sym sigma) ∪ free_svars p
   ∪ free_svars q)
Hsl2: length sl
≥ maximal_mu_depth_to sdepth E (patt_sym sigma)
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars (patt_sym sigma)
Γ ⊢i patt_sym sigma <---> patt_sym sigma using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ1, ψ2: Pattern
wfψ: well_formed (ψ1 $ ψ2)
Hsz: S (size' ψ1 + size' ψ2) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (ψ1 $ ψ2) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars (ψ1 $ ψ2) ∪ free_evars p
   ∪ free_evars q ∪ {[E]})
Hel2: length el
≥ maximal_exists_depth_to edepth E (ψ1 $ ψ2)
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars (ψ1 $ ψ2) ∪ free_svars p
   ∪ free_svars q)
Hsl2: length sl
≥ maximal_mu_depth_to sdepth E (ψ1 $ ψ2)
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars (ψ1 $ ψ2)
Γ
⊢i ψ1^[[evar:E↦p]] $ ψ2^[[evar:E↦p]] <--->
   ψ1^[[evar:E↦q]] $ ψ2^[[evar:E↦q]] using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
wfψ: well_formed ⊥
Hsz: 1 ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E ⊥ sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ⊥ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ⊥
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars ⊥ ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ⊥
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ⊥
Γ ⊢i ⊥ <---> ⊥ using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ1, ψ2: Pattern
wfψ: well_formed (ψ1 ---> ψ2)
Hsz: S (size' ψ1 + size' ψ2) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (ψ1 ---> ψ2) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars (ψ1 ---> ψ2) ∪ free_evars p
   ∪ free_evars q ∪ {[E]})
Hel2: length el
≥ maximal_exists_depth_to edepth E (ψ1 ---> ψ2)
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars (ψ1 ---> ψ2) ∪ free_svars p
   ∪ free_svars q)
Hsl2: length sl
≥ maximal_mu_depth_to sdepth E (ψ1 ---> ψ2)
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars (ψ1 ---> ψ2)
Γ
⊢i (ψ1^[[evar:E↦p]] ---> ψ2^[[evar:E↦p]]) <--->
   (ψ1^[[evar:E↦q]] ---> ψ2^[[evar:E↦q]]) using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (ex , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (ex , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars (ex , ψ) ∪ free_evars p
   ∪ free_evars q ∪ {[E]})
Hel2: length el
≥ maximal_exists_depth_to edepth E (ex , ψ)
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars (ex , ψ) ∪ free_svars p
   ∪ free_svars q)
Hsl2: length sl
≥ maximal_mu_depth_to sdepth E (ex , ψ)
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars (ex , ψ)
Γ ⊢i (ex , ψ^[[evar:E↦p]]) <---> (ex , ψ^[[evar:E↦q]])
using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (mu , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars (mu , ψ) ∪ free_evars p
   ∪ free_evars q ∪ {[E]})
Hel2: length el
≥ maximal_exists_depth_to edepth E (mu , ψ)
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars (mu , ψ) ∪ free_svars p
   ∪ free_svars q)
Hsl2: length sl
≥ maximal_mu_depth_to sdepth E (mu , ψ)
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars (mu , ψ)
Γ ⊢i (mu , ψ^[[evar:E↦p]]) <---> (mu , ψ^[[evar:E↦q]])
using gpi
    {
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
x: svar
wfψ: well_formed (patt_free_svar x)
Hsz: 1 ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (patt_free_svar x) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars (patt_free_svar x) ∪ free_evars p
   ∪ free_evars q ∪ {[E]})
Hel2: length el
≥ maximal_exists_depth_to edepth E
    (patt_free_svar x)
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars (patt_free_svar x) ∪ free_svars p
   ∪ free_svars q)
Hsl2: length sl
≥ maximal_mu_depth_to sdepth E
    (patt_free_svar x)
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars (patt_free_svar x)
Γ ⊢i patt_free_svar x <---> patt_free_svar x using gpi
      useBasicReasoning.
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
x: svar
wfψ: well_formed (patt_free_svar x)
Hsz: 1 ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (patt_free_svar x) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars (patt_free_svar x) ∪ free_evars p
   ∪ free_evars q ∪ {[E]})
Hel2: length el
≥ maximal_exists_depth_to edepth E
    (patt_free_svar x)
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars (patt_free_svar x) ∪ free_svars p
   ∪ free_svars q)
Hsl2: length sl
≥ maximal_mu_depth_to sdepth E
    (patt_free_svar x)
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars (patt_free_svar x)
Γ ⊢i patt_free_svar x <---> patt_free_svar x
using BasicReasoning
      apply pf_iff_equiv_refl.
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
x: svar
wfψ: well_formed (patt_free_svar x)
Hsz: 1 ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (patt_free_svar x) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars (patt_free_svar x) ∪ free_evars p
   ∪ free_evars q ∪ {[E]})
Hel2: length el
≥ maximal_exists_depth_to edepth E
    (patt_free_svar x)
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars (patt_free_svar x) ∪ free_svars p
   ∪ free_svars q)
Hsl2: length sl
≥ maximal_mu_depth_to sdepth E
    (patt_free_svar x)
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars (patt_free_svar x)
well_formed (patt_free_svar x)
      abstract (wf_auto2).
    }
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
n: db_index
wfψ: well_formed (patt_bound_evar n)
Hsz: 1 ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (patt_bound_evar n) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars (patt_bound_evar n)
   ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el
≥ maximal_exists_depth_to edepth E
    (patt_bound_evar n)
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars (patt_bound_evar n)
   ∪ free_svars p ∪ free_svars q)
Hsl2: length sl
≥ maximal_mu_depth_to sdepth E
    (patt_bound_evar n)
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars (patt_bound_evar n)
Γ ⊢i patt_bound_evar n <---> patt_bound_evar n
using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
n: db_index
wfψ: well_formed (patt_bound_svar n)
Hsz: 1 ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (patt_bound_svar n) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars (patt_bound_svar n)
   ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el
≥ maximal_exists_depth_to edepth E
    (patt_bound_svar n)
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars (patt_bound_svar n)
   ∪ free_svars p ∪ free_svars q)
Hsl2: length sl
≥ maximal_mu_depth_to sdepth E
    (patt_bound_svar n)
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars (patt_bound_svar n)
Γ ⊢i patt_bound_svar n <---> patt_bound_svar n
using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
sigma: symbols
wfψ: well_formed (patt_sym sigma)
Hsz: 1 ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (patt_sym sigma) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars (patt_sym sigma) ∪ free_evars p
   ∪ free_evars q ∪ {[E]})
Hel2: length el
≥ maximal_exists_depth_to edepth E
    (patt_sym sigma)
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars (patt_sym sigma) ∪ free_svars p
   ∪ free_svars q)
Hsl2: length sl
≥ maximal_mu_depth_to sdepth E (patt_sym sigma)
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars (patt_sym sigma)
Γ ⊢i patt_sym sigma <---> patt_sym sigma using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ1, ψ2: Pattern
wfψ: well_formed (ψ1 $ ψ2)
Hsz: S (size' ψ1 + size' ψ2) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (ψ1 $ ψ2) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars (ψ1 $ ψ2) ∪ free_evars p
   ∪ free_evars q ∪ {[E]})
Hel2: length el
≥ maximal_exists_depth_to edepth E (ψ1 $ ψ2)
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars (ψ1 $ ψ2) ∪ free_svars p
   ∪ free_svars q)
Hsl2: length sl
≥ maximal_mu_depth_to sdepth E (ψ1 $ ψ2)
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars (ψ1 $ ψ2)
Γ
⊢i ψ1^[[evar:E↦p]] $ ψ2^[[evar:E↦p]] <--->
   ψ1^[[evar:E↦q]] $ ψ2^[[evar:E↦q]] using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
wfψ: well_formed ⊥
Hsz: 1 ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E ⊥ sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ⊥ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ⊥
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars ⊥ ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ⊥
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ⊥
Γ ⊢i ⊥ <---> ⊥ using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ1, ψ2: Pattern
wfψ: well_formed (ψ1 ---> ψ2)
Hsz: S (size' ψ1 + size' ψ2) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (ψ1 ---> ψ2) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars (ψ1 ---> ψ2) ∪ free_evars p
   ∪ free_evars q ∪ {[E]})
Hel2: length el
≥ maximal_exists_depth_to edepth E (ψ1 ---> ψ2)
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars (ψ1 ---> ψ2) ∪ free_svars p
   ∪ free_svars q)
Hsl2: length sl
≥ maximal_mu_depth_to sdepth E (ψ1 ---> ψ2)
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars (ψ1 ---> ψ2)
Γ
⊢i (ψ1^[[evar:E↦p]] ---> ψ2^[[evar:E↦p]]) <--->
   (ψ1^[[evar:E↦q]] ---> ψ2^[[evar:E↦q]]) using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (ex , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (ex , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars (ex , ψ) ∪ free_evars p
   ∪ free_evars q ∪ {[E]})
Hel2: length el
≥ maximal_exists_depth_to edepth E (ex , ψ)
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars (ex , ψ) ∪ free_svars p
   ∪ free_svars q)
Hsl2: length sl
≥ maximal_mu_depth_to sdepth E (ex , ψ)
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars (ex , ψ)
Γ ⊢i (ex , ψ^[[evar:E↦p]]) <---> (ex , ψ^[[evar:E↦q]])
using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (mu , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars (mu , ψ) ∪ free_evars p
   ∪ free_evars q ∪ {[E]})
Hel2: length el
≥ maximal_exists_depth_to edepth E (mu , ψ)
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars (mu , ψ) ∪ free_svars p
   ∪ free_svars q)
Hsl2: length sl
≥ maximal_mu_depth_to sdepth E (mu , ψ)
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars (mu , ψ)
Γ ⊢i (mu , ψ^[[evar:E↦p]]) <---> (mu , ψ^[[evar:E↦q]])
using gpi
    {
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
n: db_index
wfψ: well_formed (patt_bound_evar n)
Hsz: 1 ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (patt_bound_evar n) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars (patt_bound_evar n)
   ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el
≥ maximal_exists_depth_to edepth E
    (patt_bound_evar n)
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars (patt_bound_evar n)
   ∪ free_svars p ∪ free_svars q)
Hsl2: length sl
≥ maximal_mu_depth_to sdepth E
    (patt_bound_evar n)
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars (patt_bound_evar n)
Γ ⊢i patt_bound_evar n <---> patt_bound_evar n
using gpi
      useBasicReasoning.
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
n: db_index
wfψ: well_formed (patt_bound_evar n)
Hsz: 1 ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (patt_bound_evar n) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars (patt_bound_evar n)
   ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el
≥ maximal_exists_depth_to edepth E
    (patt_bound_evar n)
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars (patt_bound_evar n)
   ∪ free_svars p ∪ free_svars q)
Hsl2: length sl
≥ maximal_mu_depth_to sdepth E
    (patt_bound_evar n)
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars (patt_bound_evar n)
Γ ⊢i patt_bound_evar n <---> patt_bound_evar n
using BasicReasoning
      apply pf_iff_equiv_refl.
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
n: db_index
wfψ: well_formed (patt_bound_evar n)
Hsz: 1 ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (patt_bound_evar n) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars (patt_bound_evar n)
   ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el
≥ maximal_exists_depth_to edepth E
    (patt_bound_evar n)
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars (patt_bound_evar n)
   ∪ free_svars p ∪ free_svars q)
Hsl2: length sl
≥ maximal_mu_depth_to sdepth E
    (patt_bound_evar n)
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars (patt_bound_evar n)
well_formed (patt_bound_evar n)
      abstract (wf_auto2).
    }
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
n: db_index
wfψ: well_formed (patt_bound_svar n)
Hsz: 1 ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (patt_bound_svar n) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars (patt_bound_svar n)
   ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el
≥ maximal_exists_depth_to edepth E
    (patt_bound_svar n)
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars (patt_bound_svar n)
   ∪ free_svars p ∪ free_svars q)
Hsl2: length sl
≥ maximal_mu_depth_to sdepth E
    (patt_bound_svar n)
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars (patt_bound_svar n)
Γ ⊢i patt_bound_svar n <---> patt_bound_svar n
using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
sigma: symbols
wfψ: well_formed (patt_sym sigma)
Hsz: 1 ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (patt_sym sigma) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars (patt_sym sigma) ∪ free_evars p
   ∪ free_evars q ∪ {[E]})
Hel2: length el
≥ maximal_exists_depth_to edepth E
    (patt_sym sigma)
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars (patt_sym sigma) ∪ free_svars p
   ∪ free_svars q)
Hsl2: length sl
≥ maximal_mu_depth_to sdepth E (patt_sym sigma)
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars (patt_sym sigma)
Γ ⊢i patt_sym sigma <---> patt_sym sigma using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ1, ψ2: Pattern
wfψ: well_formed (ψ1 $ ψ2)
Hsz: S (size' ψ1 + size' ψ2) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (ψ1 $ ψ2) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars (ψ1 $ ψ2) ∪ free_evars p
   ∪ free_evars q ∪ {[E]})
Hel2: length el
≥ maximal_exists_depth_to edepth E (ψ1 $ ψ2)
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars (ψ1 $ ψ2) ∪ free_svars p
   ∪ free_svars q)
Hsl2: length sl
≥ maximal_mu_depth_to sdepth E (ψ1 $ ψ2)
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars (ψ1 $ ψ2)
Γ
⊢i ψ1^[[evar:E↦p]] $ ψ2^[[evar:E↦p]] <--->
   ψ1^[[evar:E↦q]] $ ψ2^[[evar:E↦q]] using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
wfψ: well_formed ⊥
Hsz: 1 ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E ⊥ sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ⊥ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ⊥
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars ⊥ ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ⊥
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ⊥
Γ ⊢i ⊥ <---> ⊥ using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ1, ψ2: Pattern
wfψ: well_formed (ψ1 ---> ψ2)
Hsz: S (size' ψ1 + size' ψ2) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (ψ1 ---> ψ2) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars (ψ1 ---> ψ2) ∪ free_evars p
   ∪ free_evars q ∪ {[E]})
Hel2: length el
≥ maximal_exists_depth_to edepth E (ψ1 ---> ψ2)
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars (ψ1 ---> ψ2) ∪ free_svars p
   ∪ free_svars q)
Hsl2: length sl
≥ maximal_mu_depth_to sdepth E (ψ1 ---> ψ2)
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars (ψ1 ---> ψ2)
Γ
⊢i (ψ1^[[evar:E↦p]] ---> ψ2^[[evar:E↦p]]) <--->
   (ψ1^[[evar:E↦q]] ---> ψ2^[[evar:E↦q]]) using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (ex , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (ex , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars (ex , ψ) ∪ free_evars p
   ∪ free_evars q ∪ {[E]})
Hel2: length el
≥ maximal_exists_depth_to edepth E (ex , ψ)
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars (ex , ψ) ∪ free_svars p
   ∪ free_svars q)
Hsl2: length sl
≥ maximal_mu_depth_to sdepth E (ex , ψ)
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars (ex , ψ)
Γ ⊢i (ex , ψ^[[evar:E↦p]]) <---> (ex , ψ^[[evar:E↦q]])
using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (mu , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars (mu , ψ) ∪ free_evars p
   ∪ free_evars q ∪ {[E]})
Hel2: length el
≥ maximal_exists_depth_to edepth E (mu , ψ)
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars (mu , ψ) ∪ free_svars p
   ∪ free_svars q)
Hsl2: length sl
≥ maximal_mu_depth_to sdepth E (mu , ψ)
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars (mu , ψ)
Γ ⊢i (mu , ψ^[[evar:E↦p]]) <---> (mu , ψ^[[evar:E↦q]])
using gpi
    {
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
n: db_index
wfψ: well_formed (patt_bound_svar n)
Hsz: 1 ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (patt_bound_svar n) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars (patt_bound_svar n)
   ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el
≥ maximal_exists_depth_to edepth E
    (patt_bound_svar n)
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars (patt_bound_svar n)
   ∪ free_svars p ∪ free_svars q)
Hsl2: length sl
≥ maximal_mu_depth_to sdepth E
    (patt_bound_svar n)
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars (patt_bound_svar n)
Γ ⊢i patt_bound_svar n <---> patt_bound_svar n
using gpi
      useBasicReasoning.
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
n: db_index
wfψ: well_formed (patt_bound_svar n)
Hsz: 1 ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (patt_bound_svar n) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars (patt_bound_svar n)
   ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el
≥ maximal_exists_depth_to edepth E
    (patt_bound_svar n)
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars (patt_bound_svar n)
   ∪ free_svars p ∪ free_svars q)
Hsl2: length sl
≥ maximal_mu_depth_to sdepth E
    (patt_bound_svar n)
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars (patt_bound_svar n)
Γ ⊢i patt_bound_svar n <---> patt_bound_svar n
using BasicReasoning
      apply pf_iff_equiv_refl.
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
n: db_index
wfψ: well_formed (patt_bound_svar n)
Hsz: 1 ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (patt_bound_svar n) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars (patt_bound_svar n)
   ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el
≥ maximal_exists_depth_to edepth E
    (patt_bound_svar n)
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars (patt_bound_svar n)
   ∪ free_svars p ∪ free_svars q)
Hsl2: length sl
≥ maximal_mu_depth_to sdepth E
    (patt_bound_svar n)
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars (patt_bound_svar n)
well_formed (patt_bound_svar n)
      abstract (wf_auto2).
    }
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
sigma: symbols
wfψ: well_formed (patt_sym sigma)
Hsz: 1 ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (patt_sym sigma) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars (patt_sym sigma) ∪ free_evars p
   ∪ free_evars q ∪ {[E]})
Hel2: length el
≥ maximal_exists_depth_to edepth E
    (patt_sym sigma)
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars (patt_sym sigma) ∪ free_svars p
   ∪ free_svars q)
Hsl2: length sl
≥ maximal_mu_depth_to sdepth E (patt_sym sigma)
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars (patt_sym sigma)
Γ ⊢i patt_sym sigma <---> patt_sym sigma using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ1, ψ2: Pattern
wfψ: well_formed (ψ1 $ ψ2)
Hsz: S (size' ψ1 + size' ψ2) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (ψ1 $ ψ2) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars (ψ1 $ ψ2) ∪ free_evars p
   ∪ free_evars q ∪ {[E]})
Hel2: length el
≥ maximal_exists_depth_to edepth E (ψ1 $ ψ2)
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars (ψ1 $ ψ2) ∪ free_svars p
   ∪ free_svars q)
Hsl2: length sl
≥ maximal_mu_depth_to sdepth E (ψ1 $ ψ2)
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars (ψ1 $ ψ2)
Γ
⊢i ψ1^[[evar:E↦p]] $ ψ2^[[evar:E↦p]] <--->
   ψ1^[[evar:E↦q]] $ ψ2^[[evar:E↦q]] using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
wfψ: well_formed ⊥
Hsz: 1 ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E ⊥ sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ⊥ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ⊥
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars ⊥ ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ⊥
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ⊥
Γ ⊢i ⊥ <---> ⊥ using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ1, ψ2: Pattern
wfψ: well_formed (ψ1 ---> ψ2)
Hsz: S (size' ψ1 + size' ψ2) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (ψ1 ---> ψ2) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars (ψ1 ---> ψ2) ∪ free_evars p
   ∪ free_evars q ∪ {[E]})
Hel2: length el
≥ maximal_exists_depth_to edepth E (ψ1 ---> ψ2)
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars (ψ1 ---> ψ2) ∪ free_svars p
   ∪ free_svars q)
Hsl2: length sl
≥ maximal_mu_depth_to sdepth E (ψ1 ---> ψ2)
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars (ψ1 ---> ψ2)
Γ
⊢i (ψ1^[[evar:E↦p]] ---> ψ2^[[evar:E↦p]]) <--->
   (ψ1^[[evar:E↦q]] ---> ψ2^[[evar:E↦q]]) using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (ex , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (ex , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars (ex , ψ) ∪ free_evars p
   ∪ free_evars q ∪ {[E]})
Hel2: length el
≥ maximal_exists_depth_to edepth E (ex , ψ)
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars (ex , ψ) ∪ free_svars p
   ∪ free_svars q)
Hsl2: length sl
≥ maximal_mu_depth_to sdepth E (ex , ψ)
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars (ex , ψ)
Γ ⊢i (ex , ψ^[[evar:E↦p]]) <---> (ex , ψ^[[evar:E↦q]])
using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (mu , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars (mu , ψ) ∪ free_evars p
   ∪ free_evars q ∪ {[E]})
Hel2: length el
≥ maximal_exists_depth_to edepth E (mu , ψ)
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars (mu , ψ) ∪ free_svars p
   ∪ free_svars q)
Hsl2: length sl
≥ maximal_mu_depth_to sdepth E (mu , ψ)
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars (mu , ψ)
Γ ⊢i (mu , ψ^[[evar:E↦p]]) <---> (mu , ψ^[[evar:E↦q]])
using gpi
    {
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
sigma: symbols
wfψ: well_formed (patt_sym sigma)
Hsz: 1 ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (patt_sym sigma) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars (patt_sym sigma) ∪ free_evars p
   ∪ free_evars q ∪ {[E]})
Hel2: length el
≥ maximal_exists_depth_to edepth E
    (patt_sym sigma)
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars (patt_sym sigma) ∪ free_svars p
   ∪ free_svars q)
Hsl2: length sl
≥ maximal_mu_depth_to sdepth E (patt_sym sigma)
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars (patt_sym sigma)
Γ ⊢i patt_sym sigma <---> patt_sym sigma using gpi
      useBasicReasoning.
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
sigma: symbols
wfψ: well_formed (patt_sym sigma)
Hsz: 1 ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (patt_sym sigma) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars (patt_sym sigma) ∪ free_evars p
   ∪ free_evars q ∪ {[E]})
Hel2: length el
≥ maximal_exists_depth_to edepth E
    (patt_sym sigma)
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars (patt_sym sigma) ∪ free_svars p
   ∪ free_svars q)
Hsl2: length sl
≥ maximal_mu_depth_to sdepth E (patt_sym sigma)
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars (patt_sym sigma)
Γ ⊢i patt_sym sigma <---> patt_sym sigma
using BasicReasoning
      apply pf_iff_equiv_refl.
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
sigma: symbols
wfψ: well_formed (patt_sym sigma)
Hsz: 1 ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (patt_sym sigma) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars (patt_sym sigma) ∪ free_evars p
   ∪ free_evars q ∪ {[E]})
Hel2: length el
≥ maximal_exists_depth_to edepth E
    (patt_sym sigma)
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars (patt_sym sigma) ∪ free_svars p
   ∪ free_svars q)
Hsl2: length sl
≥ maximal_mu_depth_to sdepth E (patt_sym sigma)
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars (patt_sym sigma)
well_formed (patt_sym sigma)
      abstract (wf_auto2).
    }
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ1, ψ2: Pattern
wfψ: well_formed (ψ1 $ ψ2)
Hsz: S (size' ψ1 + size' ψ2) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (ψ1 $ ψ2) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars (ψ1 $ ψ2) ∪ free_evars p
   ∪ free_evars q ∪ {[E]})
Hel2: length el
≥ maximal_exists_depth_to edepth E (ψ1 $ ψ2)
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars (ψ1 $ ψ2) ∪ free_svars p
   ∪ free_svars q)
Hsl2: length sl
≥ maximal_mu_depth_to sdepth E (ψ1 $ ψ2)
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars (ψ1 $ ψ2)
Γ
⊢i ψ1^[[evar:E↦p]] $ ψ2^[[evar:E↦p]] <--->
   ψ1^[[evar:E↦q]] $ ψ2^[[evar:E↦q]] using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
wfψ: well_formed ⊥
Hsz: 1 ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E ⊥ sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ⊥ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ⊥
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars ⊥ ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ⊥
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ⊥
Γ ⊢i ⊥ <---> ⊥ using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ1, ψ2: Pattern
wfψ: well_formed (ψ1 ---> ψ2)
Hsz: S (size' ψ1 + size' ψ2) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (ψ1 ---> ψ2) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars (ψ1 ---> ψ2) ∪ free_evars p
   ∪ free_evars q ∪ {[E]})
Hel2: length el
≥ maximal_exists_depth_to edepth E (ψ1 ---> ψ2)
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars (ψ1 ---> ψ2) ∪ free_svars p
   ∪ free_svars q)
Hsl2: length sl
≥ maximal_mu_depth_to sdepth E (ψ1 ---> ψ2)
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars (ψ1 ---> ψ2)
Γ
⊢i (ψ1^[[evar:E↦p]] ---> ψ2^[[evar:E↦p]]) <--->
   (ψ1^[[evar:E↦q]] ---> ψ2^[[evar:E↦q]]) using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (ex , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (ex , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars (ex , ψ) ∪ free_evars p
   ∪ free_evars q ∪ {[E]})
Hel2: length el
≥ maximal_exists_depth_to edepth E (ex , ψ)
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars (ex , ψ) ∪ free_svars p
   ∪ free_svars q)
Hsl2: length sl
≥ maximal_mu_depth_to sdepth E (ex , ψ)
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars (ex , ψ)
Γ ⊢i (ex , ψ^[[evar:E↦p]]) <---> (ex , ψ^[[evar:E↦q]])
using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (mu , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars (mu , ψ) ∪ free_evars p
   ∪ free_evars q ∪ {[E]})
Hel2: length el
≥ maximal_exists_depth_to edepth E (mu , ψ)
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars (mu , ψ) ∪ free_svars p
   ∪ free_svars q)
Hsl2: length sl
≥ maximal_mu_depth_to sdepth E (mu , ψ)
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars (mu , ψ)
Γ ⊢i (mu , ψ^[[evar:E↦p]]) <---> (mu , ψ^[[evar:E↦q]])
using gpi
    {
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ1, ψ2: Pattern
wfψ: well_formed (ψ1 $ ψ2)
Hsz: S (size' ψ1 + size' ψ2) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (ψ1 $ ψ2) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars (ψ1 $ ψ2) ∪ free_evars p
   ∪ free_evars q ∪ {[E]})
Hel2: length el
≥ maximal_exists_depth_to edepth E (ψ1 $ ψ2)
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars (ψ1 $ ψ2) ∪ free_svars p
   ∪ free_svars q)
Hsl2: length sl
≥ maximal_mu_depth_to sdepth E (ψ1 $ ψ2)
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars (ψ1 $ ψ2)
Γ
⊢i ψ1^[[evar:E↦p]] $ ψ2^[[evar:E↦p]] <--->
   ψ1^[[evar:E↦q]] $ ψ2^[[evar:E↦q]] using gpi
      assert (wfψ1 : well_formed ψ1 = true).
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ1, ψ2: Pattern
wfψ: well_formed (ψ1 $ ψ2)
Hsz: S (size' ψ1 + size' ψ2) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (ψ1 $ ψ2) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars (ψ1 $ ψ2) ∪ free_evars p
   ∪ free_evars q ∪ {[E]})
Hel2: length el
≥ maximal_exists_depth_to edepth E (ψ1 $ ψ2)
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars (ψ1 $ ψ2) ∪ free_svars p
   ∪ free_svars q)
Hsl2: length sl
≥ maximal_mu_depth_to sdepth E (ψ1 $ ψ2)
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars (ψ1 $ ψ2)
well_formed ψ1 = true
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ1, ψ2: Pattern
wfψ: well_formed (ψ1 $ ψ2)
Hsz: S (size' ψ1 + size' ψ2) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (ψ1 $ ψ2) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars (ψ1 $ ψ2) ∪ free_evars p
   ∪ free_evars q ∪ {[E]})
Hel2: length el
≥ maximal_exists_depth_to edepth E (ψ1 $ ψ2)
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars (ψ1 $ ψ2) ∪ free_svars p
   ∪ free_svars q)
Hsl2: length sl
≥ maximal_mu_depth_to sdepth E (ψ1 $ ψ2)
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars (ψ1 $ ψ2)
wfψ1: well_formed ψ1 = true
Γ
⊢i ψ1^[[evar:E↦p]] $ ψ2^[[evar:E↦p]] <--->
   ψ1^[[evar:E↦q]] $ ψ2^[[evar:E↦q]] using gpi
      {
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ1, ψ2: Pattern
wfψ: well_formed (ψ1 $ ψ2)
Hsz: S (size' ψ1 + size' ψ2) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (ψ1 $ ψ2) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars (ψ1 $ ψ2) ∪ free_evars p
   ∪ free_evars q ∪ {[E]})
Hel2: length el
≥ maximal_exists_depth_to edepth E (ψ1 $ ψ2)
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars (ψ1 $ ψ2) ∪ free_svars p
   ∪ free_svars q)
Hsl2: length sl
≥ maximal_mu_depth_to sdepth E (ψ1 $ ψ2)
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars (ψ1 $ ψ2)
well_formed ψ1 = true clear -wfψ.
Σ: Signature
ψ1, ψ2: Pattern
wfψ: well_formed (ψ1 $ ψ2)
well_formed ψ1 = true abstract (wf_auto2). }
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ1, ψ2: Pattern
wfψ: well_formed (ψ1 $ ψ2)
Hsz: S (size' ψ1 + size' ψ2) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (ψ1 $ ψ2) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars (ψ1 $ ψ2) ∪ free_evars p
   ∪ free_evars q ∪ {[E]})
Hel2: length el
≥ maximal_exists_depth_to edepth E (ψ1 $ ψ2)
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars (ψ1 $ ψ2) ∪ free_svars p
   ∪ free_svars q)
Hsl2: length sl
≥ maximal_mu_depth_to sdepth E (ψ1 $ ψ2)
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars (ψ1 $ ψ2)
wfψ1: well_formed ψ1 = true
Γ
⊢i ψ1^[[evar:E↦p]] $ ψ2^[[evar:E↦p]] <--->
   ψ1^[[evar:E↦q]] $ ψ2^[[evar:E↦q]] using gpi
      assert (size' ψ1 <= sz) by abstract(lia).
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ1, ψ2: Pattern
wfψ: well_formed (ψ1 $ ψ2)
Hsz: S (size' ψ1 + size' ψ2) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (ψ1 $ ψ2) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars (ψ1 $ ψ2) ∪ free_evars p
   ∪ free_evars q ∪ {[E]})
Hel2: length el
≥ maximal_exists_depth_to edepth E (ψ1 $ ψ2)
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars (ψ1 $ ψ2) ∪ free_svars p
   ∪ free_svars q)
Hsl2: length sl
≥ maximal_mu_depth_to sdepth E (ψ1 $ ψ2)
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars (ψ1 $ ψ2)
wfψ1: well_formed ψ1 = true
H: size' ψ1 ≤ sz
Γ
⊢i ψ1^[[evar:E↦p]] $ ψ2^[[evar:E↦p]] <--->
   ψ1^[[evar:E↦q]] $ ψ2^[[evar:E↦q]] using gpi
      assert (wfψ2 : well_formed ψ2 = true).
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ1, ψ2: Pattern
wfψ: well_formed (ψ1 $ ψ2)
Hsz: S (size' ψ1 + size' ψ2) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (ψ1 $ ψ2) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars (ψ1 $ ψ2) ∪ free_evars p
   ∪ free_evars q ∪ {[E]})
Hel2: length el
≥ maximal_exists_depth_to edepth E (ψ1 $ ψ2)
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars (ψ1 $ ψ2) ∪ free_svars p
   ∪ free_svars q)
Hsl2: length sl
≥ maximal_mu_depth_to sdepth E (ψ1 $ ψ2)
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars (ψ1 $ ψ2)
wfψ1: well_formed ψ1 = true
H: size' ψ1 ≤ sz
well_formed ψ2 = true
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ1, ψ2: Pattern
wfψ: well_formed (ψ1 $ ψ2)
Hsz: S (size' ψ1 + size' ψ2) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (ψ1 $ ψ2) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars (ψ1 $ ψ2) ∪ free_evars p
   ∪ free_evars q ∪ {[E]})
Hel2: length el
≥ maximal_exists_depth_to edepth E (ψ1 $ ψ2)
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars (ψ1 $ ψ2) ∪ free_svars p
   ∪ free_svars q)
Hsl2: length sl
≥ maximal_mu_depth_to sdepth E (ψ1 $ ψ2)
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars (ψ1 $ ψ2)
wfψ1: well_formed ψ1 = true
H: size' ψ1 ≤ sz
wfψ2: well_formed ψ2 = true
Γ
⊢i ψ1^[[evar:E↦p]] $ ψ2^[[evar:E↦p]] <--->
   ψ1^[[evar:E↦q]] $ ψ2^[[evar:E↦q]] using gpi
      {
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ1, ψ2: Pattern
wfψ: well_formed (ψ1 $ ψ2)
Hsz: S (size' ψ1 + size' ψ2) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (ψ1 $ ψ2) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars (ψ1 $ ψ2) ∪ free_evars p
   ∪ free_evars q ∪ {[E]})
Hel2: length el
≥ maximal_exists_depth_to edepth E (ψ1 $ ψ2)
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars (ψ1 $ ψ2) ∪ free_svars p
   ∪ free_svars q)
Hsl2: length sl
≥ maximal_mu_depth_to sdepth E (ψ1 $ ψ2)
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars (ψ1 $ ψ2)
wfψ1: well_formed ψ1 = true
H: size' ψ1 ≤ sz
well_formed ψ2 = true clear -wfψ.
Σ: Signature
ψ1, ψ2: Pattern
wfψ: well_formed (ψ1 $ ψ2)
well_formed ψ2 = true abstract (wf_auto2). }
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ1, ψ2: Pattern
wfψ: well_formed (ψ1 $ ψ2)
Hsz: S (size' ψ1 + size' ψ2) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (ψ1 $ ψ2) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars (ψ1 $ ψ2) ∪ free_evars p
   ∪ free_evars q ∪ {[E]})
Hel2: length el
≥ maximal_exists_depth_to edepth E (ψ1 $ ψ2)
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars (ψ1 $ ψ2) ∪ free_svars p
   ∪ free_svars q)
Hsl2: length sl
≥ maximal_mu_depth_to sdepth E (ψ1 $ ψ2)
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars (ψ1 $ ψ2)
wfψ1: well_formed ψ1 = true
H: size' ψ1 ≤ sz
wfψ2: well_formed ψ2 = true
Γ
⊢i ψ1^[[evar:E↦p]] $ ψ2^[[evar:E↦p]] <--->
   ψ1^[[evar:E↦q]] $ ψ2^[[evar:E↦q]] using gpi
      assert (size' ψ2 <= sz) by abstract(lia).
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ1, ψ2: Pattern
wfψ: well_formed (ψ1 $ ψ2)
Hsz: S (size' ψ1 + size' ψ2) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (ψ1 $ ψ2) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars (ψ1 $ ψ2) ∪ free_evars p
   ∪ free_evars q ∪ {[E]})
Hel2: length el
≥ maximal_exists_depth_to edepth E (ψ1 $ ψ2)
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars (ψ1 $ ψ2) ∪ free_svars p
   ∪ free_svars q)
Hsl2: length sl
≥ maximal_mu_depth_to sdepth E (ψ1 $ ψ2)
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars (ψ1 $ ψ2)
wfψ1: well_formed ψ1 = true
H: size' ψ1 ≤ sz
wfψ2: well_formed ψ2 = true
H0: size' ψ2 ≤ sz
Γ
⊢i ψ1^[[evar:E↦p]] $ ψ2^[[evar:E↦p]] <--->
   ψ1^[[evar:E↦q]] $ ψ2^[[evar:E↦q]] using gpi
      
      simpl in *.
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ1, ψ2: Pattern
wfψ: well_formed (ψ1 $ ψ2)
Hsz: S (size' ψ1 + size' ψ2) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (ψ1 $ ψ2) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ψ1 ∪ free_evars ψ2 ∪ free_evars p
   ∪ free_evars q ∪ {[E]})
Hel2: length el
≥ maximal_exists_depth_to edepth E ψ1
  `max` maximal_exists_depth_to edepth E ψ2
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars ψ1 ∪ free_svars ψ2 ∪ free_svars p
   ∪ free_svars q)
Hsl2: length sl
≥ maximal_mu_depth_to sdepth E ψ1
  `max` maximal_mu_depth_to sdepth E ψ2
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ1 ∪ free_evars ψ2
wfψ1: well_formed ψ1 = true
H: size' ψ1 ≤ sz
wfψ2: well_formed ψ2 = true
H0: size' ψ2 ≤ sz
Γ
⊢i ψ1^[[evar:E↦p]] $ ψ2^[[evar:E↦p]] <--->
   ψ1^[[evar:E↦q]] $ ψ2^[[evar:E↦q]] using gpi
      pose proof (Hef1 := fresh_evars_bigger (free_evars ψ1 ∪ free_evars p ∪ free_evars q ∪ {[E]}) Hel1 ltac:(set_solver)).
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ1, ψ2: Pattern
wfψ: well_formed (ψ1 $ ψ2)
Hsz: S (size' ψ1 + size' ψ2) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (ψ1 $ ψ2) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ψ1 ∪ free_evars ψ2 ∪ free_evars p
   ∪ free_evars q ∪ {[E]})
Hel2: length el
≥ maximal_exists_depth_to edepth E ψ1
  `max` maximal_exists_depth_to edepth E ψ2
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars ψ1 ∪ free_svars ψ2 ∪ free_svars p
   ∪ free_svars q)
Hsl2: length sl
≥ maximal_mu_depth_to sdepth E ψ1
  `max` maximal_mu_depth_to sdepth E ψ2
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ1 ∪ free_evars ψ2
wfψ1: well_formed ψ1 = true
H: size' ψ1 ≤ sz
wfψ2: well_formed ψ2 = true
H0: size' ψ2 ≤ sz
Hef1: fresh_evars el
  (free_evars ψ1 ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Γ
⊢i ψ1^[[evar:E↦p]] $ ψ2^[[evar:E↦p]] <--->
   ψ1^[[evar:E↦q]] $ ψ2^[[evar:E↦q]] using gpi
      
      pose proof (Hsf1 := fresh_svars_bigger (free_svars ψ1 ∪ free_svars p ∪ free_svars q) Hsl1 ltac:(set_solver)).
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ1, ψ2: Pattern
wfψ: well_formed (ψ1 $ ψ2)
Hsz: S (size' ψ1 + size' ψ2) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (ψ1 $ ψ2) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ψ1 ∪ free_evars ψ2 ∪ free_evars p
   ∪ free_evars q ∪ {[E]})
Hel2: length el
≥ maximal_exists_depth_to edepth E ψ1
  `max` maximal_exists_depth_to edepth E ψ2
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars ψ1 ∪ free_svars ψ2 ∪ free_svars p
   ∪ free_svars q)
Hsl2: length sl
≥ maximal_mu_depth_to sdepth E ψ1
  `max` maximal_mu_depth_to sdepth E ψ2
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ1 ∪ free_evars ψ2
wfψ1: well_formed ψ1 = true
H: size' ψ1 ≤ sz
wfψ2: well_formed ψ2 = true
H0: size' ψ2 ≤ sz
Hef1: fresh_evars el
  (free_evars ψ1 ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hsf1: fresh_svars sl
  (free_svars ψ1 ∪ free_svars p ∪ free_svars q)
Γ
⊢i ψ1^[[evar:E↦p]] $ ψ2^[[evar:E↦p]] <--->
   ψ1^[[evar:E↦q]] $ ψ2^[[evar:E↦q]] using gpi
      
      unshelve (epose proof (pf₁ := IHsz edepth sdepth ψ1 ltac:(assumption) ltac:(assumption) evs svs gpi _ pf el Hef1 _ Hel3 sl Hsf1 _ Hsl3)).
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ1, ψ2: Pattern
wfψ: well_formed (ψ1 $ ψ2)
Hsz: S (size' ψ1 + size' ψ2) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (ψ1 $ ψ2) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ψ1 ∪ free_evars ψ2 ∪ free_evars p
   ∪ free_evars q ∪ {[E]})
Hel2: length el
≥ maximal_exists_depth_to edepth E ψ1
  `max` maximal_exists_depth_to edepth E ψ2
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars ψ1 ∪ free_svars ψ2 ∪ free_svars p
   ∪ free_svars q)
Hsl2: length sl
≥ maximal_mu_depth_to sdepth E ψ1
  `max` maximal_mu_depth_to sdepth E ψ2
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ1 ∪ free_evars ψ2
wfψ1: well_formed ψ1 = true
H: size' ψ1 ≤ sz
wfψ2: well_formed ψ2 = true
H0: size' ψ2 ≤ sz
Hef1: fresh_evars el
  (free_evars ψ1 ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hsf1: fresh_svars sl
  (free_svars ψ1 ∪ free_svars p ∪ free_svars q)
ProofInfoLe
  (ExGen := evs, SVSubst := svs,
   KT := mu_in_evar_path E ψ1 sdepth) gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ1, ψ2: Pattern
wfψ: well_formed (ψ1 $ ψ2)
Hsz: S (size' ψ1 + size' ψ2) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (ψ1 $ ψ2) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ψ1 ∪ free_evars ψ2 ∪ free_evars p
   ∪ free_evars q ∪ {[E]})
Hel2: length el
≥ maximal_exists_depth_to edepth E ψ1
  `max` maximal_exists_depth_to edepth E ψ2
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars ψ1 ∪ free_svars ψ2 ∪ free_svars p
   ∪ free_svars q)
Hsl2: length sl
≥ maximal_mu_depth_to sdepth E ψ1
  `max` maximal_mu_depth_to sdepth E ψ2
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ1 ∪ free_evars ψ2
wfψ1: well_formed ψ1 = true
H: size' ψ1 ≤ sz
wfψ2: well_formed ψ2 = true
H0: size' ψ2 ≤ sz
Hef1: fresh_evars el
  (free_evars ψ1 ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hsf1: fresh_svars sl
  (free_svars ψ1 ∪ free_svars p ∪ free_svars q)
length el ≥ maximal_exists_depth_to edepth E ψ1
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ1, ψ2: Pattern
wfψ: well_formed (ψ1 $ ψ2)
Hsz: S (size' ψ1 + size' ψ2) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (ψ1 $ ψ2) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ψ1 ∪ free_evars ψ2 ∪ free_evars p
   ∪ free_evars q ∪ {[E]})
Hel2: length el
≥ maximal_exists_depth_to edepth E ψ1
  `max` maximal_exists_depth_to edepth E ψ2
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars ψ1 ∪ free_svars ψ2 ∪ free_svars p
   ∪ free_svars q)
Hsl2: length sl
≥ maximal_mu_depth_to sdepth E ψ1
  `max` maximal_mu_depth_to sdepth E ψ2
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ1 ∪ free_evars ψ2
wfψ1: well_formed ψ1 = true
H: size' ψ1 ≤ sz
wfψ2: well_formed ψ2 = true
H0: size' ψ2 ≤ sz
Hef1: fresh_evars el
  (free_evars ψ1 ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hsf1: fresh_svars sl
  (free_svars ψ1 ∪ free_svars p ∪ free_svars q)
length sl ≥ maximal_mu_depth_to sdepth E ψ1
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ1, ψ2: Pattern
wfψ: well_formed (ψ1 $ ψ2)
Hsz: S (size' ψ1 + size' ψ2) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (ψ1 $ ψ2) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ψ1 ∪ free_evars ψ2 ∪ free_evars p
   ∪ free_evars q ∪ {[E]})
Hel2: length el
≥ maximal_exists_depth_to edepth E ψ1
  `max` maximal_exists_depth_to edepth E ψ2
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars ψ1 ∪ free_svars ψ2 ∪ free_svars p
   ∪ free_svars q)
Hsl2: length sl
≥ maximal_mu_depth_to sdepth E ψ1
  `max` maximal_mu_depth_to sdepth E ψ2
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ1 ∪ free_evars ψ2
wfψ1: well_formed ψ1 = true
H: size' ψ1 ≤ sz
wfψ2: well_formed ψ2 = true
H0: size' ψ2 ≤ sz
Hef1: fresh_evars el
  (free_evars ψ1 ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hsf1: fresh_svars sl
  (free_svars ψ1 ∪ free_svars p ∪ free_svars q)
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]]
using gpi
Γ
⊢i ψ1^[[evar:E↦p]] $ ψ2^[[evar:E↦p]] <--->
   ψ1^[[evar:E↦q]] $ ψ2^[[evar:E↦q]] using gpi 2-3: lia.
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ1, ψ2: Pattern
wfψ: well_formed (ψ1 $ ψ2)
Hsz: S (size' ψ1 + size' ψ2) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (ψ1 $ ψ2) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ψ1 ∪ free_evars ψ2 ∪ free_evars p
   ∪ free_evars q ∪ {[E]})
Hel2: length el
≥ maximal_exists_depth_to edepth E ψ1
  `max` maximal_exists_depth_to edepth E ψ2
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars ψ1 ∪ free_svars ψ2 ∪ free_svars p
   ∪ free_svars q)
Hsl2: length sl
≥ maximal_mu_depth_to sdepth E ψ1
  `max` maximal_mu_depth_to sdepth E ψ2
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ1 ∪ free_evars ψ2
wfψ1: well_formed ψ1 = true
H: size' ψ1 ≤ sz
wfψ2: well_formed ψ2 = true
H0: size' ψ2 ≤ sz
Hef1: fresh_evars el
  (free_evars ψ1 ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hsf1: fresh_svars sl
  (free_svars ψ1 ∪ free_svars p ∪ free_svars q)
ProofInfoLe
  (ExGen := evs, SVSubst := svs,
   KT := mu_in_evar_path E ψ1 sdepth) gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ1, ψ2: Pattern
wfψ: well_formed (ψ1 $ ψ2)
Hsz: S (size' ψ1 + size' ψ2) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (ψ1 $ ψ2) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ψ1 ∪ free_evars ψ2 ∪ free_evars p
   ∪ free_evars q ∪ {[E]})
Hel2: length el
≥ maximal_exists_depth_to edepth E ψ1
  `max` maximal_exists_depth_to edepth E ψ2
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars ψ1 ∪ free_svars ψ2 ∪ free_svars p
   ∪ free_svars q)
Hsl2: length sl
≥ maximal_mu_depth_to sdepth E ψ1
  `max` maximal_mu_depth_to sdepth E ψ2
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ1 ∪ free_evars ψ2
wfψ1: well_formed ψ1 = true
H: size' ψ1 ≤ sz
wfψ2: well_formed ψ2 = true
H0: size' ψ2 ≤ sz
Hef1: fresh_evars el
  (free_evars ψ1 ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hsf1: fresh_svars sl
  (free_svars ψ1 ∪ free_svars p ∪ free_svars q)
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]]
using gpi
Γ
⊢i ψ1^[[evar:E↦p]] $ ψ2^[[evar:E↦p]] <--->
   ψ1^[[evar:E↦q]] $ ψ2^[[evar:E↦q]] using gpi
      {
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ1, ψ2: Pattern
wfψ: well_formed (ψ1 $ ψ2)
Hsz: S (size' ψ1 + size' ψ2) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (ψ1 $ ψ2) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ψ1 ∪ free_evars ψ2 ∪ free_evars p
   ∪ free_evars q ∪ {[E]})
Hel2: length el
≥ maximal_exists_depth_to edepth E ψ1
  `max` maximal_exists_depth_to edepth E ψ2
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars ψ1 ∪ free_svars ψ2 ∪ free_svars p
   ∪ free_svars q)
Hsl2: length sl
≥ maximal_mu_depth_to sdepth E ψ1
  `max` maximal_mu_depth_to sdepth E ψ2
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ1 ∪ free_evars ψ2
wfψ1: well_formed ψ1 = true
H: size' ψ1 ≤ sz
wfψ2: well_formed ψ2 = true
H0: size' ψ2 ≤ sz
Hef1: fresh_evars el
  (free_evars ψ1 ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hsf1: fresh_svars sl
  (free_svars ψ1 ∪ free_svars p ∪ free_svars q)
ProofInfoLe
  (ExGen := evs, SVSubst := svs,
   KT := mu_in_evar_path E ψ1 sdepth) gpi clear - i' pile.
Σ: Signature
E: evar
sdepth: nat
ψ1, ψ2: Pattern
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (ψ1 $ ψ2) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
ProofInfoLe
  (ExGen := evs, SVSubst := svs,
   KT := mu_in_evar_path E ψ1 sdepth) gpi try_solve_pile.
Σ: Signature
E: evar
sdepth: nat
ψ1, ψ2: Pattern
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (ψ1 $ ψ2) sdepth: ProofInfo
H: evs ⊆ pi_generalized_evars gpi
H0: svs ⊆ pi_substituted_svars gpi
H1: mu_in_evar_path E (ψ1 $ ψ2) sdepth ==>
pi_uses_kt gpi
pi_uses_kt
  (ExGen := evs, SVSubst := svs,
   KT := mu_in_evar_path E ψ1 sdepth) ==>
pi_uses_kt gpi
        cbn in *.
Σ: Signature
E: evar
sdepth: nat
ψ1, ψ2: Pattern
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (ψ1 $ ψ2) sdepth: ProofInfo
H: evs ⊆ pi_generalized_evars gpi
H0: svs ⊆ pi_substituted_svars gpi
H1: mu_in_evar_path E (ψ1 $ ψ2) sdepth ==>
pi_uses_kt gpi
mu_in_evar_path E ψ1 sdepth ==> pi_uses_kt gpi unfold mu_in_evar_path in *.
Σ: Signature
E: evar
sdepth: nat
ψ1, ψ2: Pattern
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := ~~
      (0 =? maximal_mu_depth_to sdepth E (ψ1 $ ψ2))%nat: ProofInfo
H: evs ⊆ pi_generalized_evars gpi
H0: svs ⊆ pi_substituted_svars gpi
H1: ~~
(0 =? maximal_mu_depth_to sdepth E (ψ1 $ ψ2))%nat ==>
pi_uses_kt gpi
~~ (0 =? maximal_mu_depth_to sdepth E ψ1)%nat ==>
pi_uses_kt gpi cbn in *.
Σ: Signature
E: evar
sdepth: nat
ψ1, ψ2: Pattern
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := ~~
      match
        maximal_mu_depth_to sdepth E ψ1
        `max` maximal_mu_depth_to sdepth E ψ2
      with
      | 0 => true
      | S _ => false
      end: ProofInfo
H: evs ⊆ pi_generalized_evars gpi
H0: svs ⊆ pi_substituted_svars gpi
H1: ~~
match
  maximal_mu_depth_to sdepth E ψ1
  `max` maximal_mu_depth_to sdepth E ψ2
with
| 0 => true
| S _ => false
end ==> pi_uses_kt gpi
~~
match maximal_mu_depth_to sdepth E ψ1 with
| 0 => true
| S _ => false
end ==> pi_uses_kt gpi
        do 2 case_match; cbn in *; auto.
Σ: Signature
E: evar
sdepth: nat
ψ1, ψ2: Pattern
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
n: nat
H3: maximal_mu_depth_to sdepth E ψ1 = S n
H2: S n `max` maximal_mu_depth_to sdepth E ψ2 = 0
i':= ExGen := evs, SVSubst := svs, KT := false: ProofInfo
H: evs ⊆ pi_generalized_evars gpi
H0: svs ⊆ pi_substituted_svars gpi
H1: true
pi_uses_kt gpi lia. }
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ1, ψ2: Pattern
wfψ: well_formed (ψ1 $ ψ2)
Hsz: S (size' ψ1 + size' ψ2) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (ψ1 $ ψ2) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ψ1 ∪ free_evars ψ2 ∪ free_evars p
   ∪ free_evars q ∪ {[E]})
Hel2: length el
≥ maximal_exists_depth_to edepth E ψ1
  `max` maximal_exists_depth_to edepth E ψ2
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars ψ1 ∪ free_svars ψ2 ∪ free_svars p
   ∪ free_svars q)
Hsl2: length sl
≥ maximal_mu_depth_to sdepth E ψ1
  `max` maximal_mu_depth_to sdepth E ψ2
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ1 ∪ free_evars ψ2
wfψ1: well_formed ψ1 = true
H: size' ψ1 ≤ sz
wfψ2: well_formed ψ2 = true
H0: size' ψ2 ≤ sz
Hef1: fresh_evars el
  (free_evars ψ1 ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hsf1: fresh_svars sl
  (free_svars ψ1 ∪ free_svars p ∪ free_svars q)
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]]
using gpi
Γ
⊢i ψ1^[[evar:E↦p]] $ ψ2^[[evar:E↦p]] <--->
   ψ1^[[evar:E↦q]] $ ψ2^[[evar:E↦q]] using gpi

      epose proof (Hef2 := fresh_evars_bigger (free_evars ψ2 ∪ free_evars p ∪ free_evars q ∪ {[E]}) Hel1 ltac:(set_solver)).
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ1, ψ2: Pattern
wfψ: well_formed (ψ1 $ ψ2)
Hsz: S (size' ψ1 + size' ψ2) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (ψ1 $ ψ2) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ψ1 ∪ free_evars ψ2 ∪ free_evars p
   ∪ free_evars q ∪ {[E]})
Hel2: length el
≥ maximal_exists_depth_to edepth E ψ1
  `max` maximal_exists_depth_to edepth E ψ2
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars ψ1 ∪ free_svars ψ2 ∪ free_svars p
   ∪ free_svars q)
Hsl2: length sl
≥ maximal_mu_depth_to sdepth E ψ1
  `max` maximal_mu_depth_to sdepth E ψ2
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ1 ∪ free_evars ψ2
wfψ1: well_formed ψ1 = true
H: size' ψ1 ≤ sz
wfψ2: well_formed ψ2 = true
H0: size' ψ2 ≤ sz
Hef1: fresh_evars el
  (free_evars ψ1 ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hsf1: fresh_svars sl
  (free_svars ψ1 ∪ free_svars p ∪ free_svars q)
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]]
using gpi
Hef2: fresh_evars el
  (free_evars ψ2 ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Γ
⊢i ψ1^[[evar:E↦p]] $ ψ2^[[evar:E↦p]] <--->
   ψ1^[[evar:E↦q]] $ ψ2^[[evar:E↦q]] using gpi

      pose proof (Hsf2 := fresh_svars_bigger (free_svars ψ2 ∪ free_svars p ∪ free_svars q) Hsl1 ltac:(set_solver)).
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ1, ψ2: Pattern
wfψ: well_formed (ψ1 $ ψ2)
Hsz: S (size' ψ1 + size' ψ2) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (ψ1 $ ψ2) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ψ1 ∪ free_evars ψ2 ∪ free_evars p
   ∪ free_evars q ∪ {[E]})
Hel2: length el
≥ maximal_exists_depth_to edepth E ψ1
  `max` maximal_exists_depth_to edepth E ψ2
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars ψ1 ∪ free_svars ψ2 ∪ free_svars p
   ∪ free_svars q)
Hsl2: length sl
≥ maximal_mu_depth_to sdepth E ψ1
  `max` maximal_mu_depth_to sdepth E ψ2
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ1 ∪ free_evars ψ2
wfψ1: well_formed ψ1 = true
H: size' ψ1 ≤ sz
wfψ2: well_formed ψ2 = true
H0: size' ψ2 ≤ sz
Hef1: fresh_evars el
  (free_evars ψ1 ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hsf1: fresh_svars sl
  (free_svars ψ1 ∪ free_svars p ∪ free_svars q)
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]]
using gpi
Hef2: fresh_evars el
  (free_evars ψ2 ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hsf2: fresh_svars sl
  (free_svars ψ2 ∪ free_svars p ∪ free_svars q)
Γ
⊢i ψ1^[[evar:E↦p]] $ ψ2^[[evar:E↦p]] <--->
   ψ1^[[evar:E↦q]] $ ψ2^[[evar:E↦q]] using gpi

      unshelve (epose proof (pf₂ := IHsz edepth sdepth ψ2 ltac:(assumption) ltac:(assumption) evs svs gpi _ pf el Hef2 ltac:(lia) Hel3 sl Hsf2 ltac:(lia) Hsl3)).
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ1, ψ2: Pattern
wfψ: well_formed (ψ1 $ ψ2)
Hsz: S (size' ψ1 + size' ψ2) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (ψ1 $ ψ2) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ψ1 ∪ free_evars ψ2 ∪ free_evars p
   ∪ free_evars q ∪ {[E]})
Hel2: length el
≥ maximal_exists_depth_to edepth E ψ1
  `max` maximal_exists_depth_to edepth E ψ2
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars ψ1 ∪ free_svars ψ2 ∪ free_svars p
   ∪ free_svars q)
Hsl2: length sl
≥ maximal_mu_depth_to sdepth E ψ1
  `max` maximal_mu_depth_to sdepth E ψ2
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ1 ∪ free_evars ψ2
wfψ1: well_formed ψ1 = true
H: size' ψ1 ≤ sz
wfψ2: well_formed ψ2 = true
H0: size' ψ2 ≤ sz
Hef1: fresh_evars el
  (free_evars ψ1 ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hsf1: fresh_svars sl
  (free_svars ψ1 ∪ free_svars p ∪ free_svars q)
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]]
using gpi
Hef2: fresh_evars el
  (free_evars ψ2 ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hsf2: fresh_svars sl
  (free_svars ψ2 ∪ free_svars p ∪ free_svars q)
ProofInfoLe
  (ExGen := evs, SVSubst := svs,
   KT := mu_in_evar_path E ψ2 sdepth) gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ1, ψ2: Pattern
wfψ: well_formed (ψ1 $ ψ2)
Hsz: S (size' ψ1 + size' ψ2) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (ψ1 $ ψ2) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ψ1 ∪ free_evars ψ2 ∪ free_evars p
   ∪ free_evars q ∪ {[E]})
Hel2: length el
≥ maximal_exists_depth_to edepth E ψ1
  `max` maximal_exists_depth_to edepth E ψ2
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars ψ1 ∪ free_svars ψ2 ∪ free_svars p
   ∪ free_svars q)
Hsl2: length sl
≥ maximal_mu_depth_to sdepth E ψ1
  `max` maximal_mu_depth_to sdepth E ψ2
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ1 ∪ free_evars ψ2
wfψ1: well_formed ψ1 = true
H: size' ψ1 ≤ sz
wfψ2: well_formed ψ2 = true
H0: size' ψ2 ≤ sz
Hef1: fresh_evars el
  (free_evars ψ1 ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hsf1: fresh_svars sl
  (free_svars ψ1 ∪ free_svars p ∪ free_svars q)
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]]
using gpi
Hef2: fresh_evars el
  (free_evars ψ2 ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hsf2: fresh_svars sl
  (free_svars ψ2 ∪ free_svars p ∪ free_svars q)
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]]
using gpi
Γ
⊢i ψ1^[[evar:E↦p]] $ ψ2^[[evar:E↦p]] <--->
   ψ1^[[evar:E↦q]] $ ψ2^[[evar:E↦q]] using gpi
      {
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ1, ψ2: Pattern
wfψ: well_formed (ψ1 $ ψ2)
Hsz: S (size' ψ1 + size' ψ2) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (ψ1 $ ψ2) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ψ1 ∪ free_evars ψ2 ∪ free_evars p
   ∪ free_evars q ∪ {[E]})
Hel2: length el
≥ maximal_exists_depth_to edepth E ψ1
  `max` maximal_exists_depth_to edepth E ψ2
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars ψ1 ∪ free_svars ψ2 ∪ free_svars p
   ∪ free_svars q)
Hsl2: length sl
≥ maximal_mu_depth_to sdepth E ψ1
  `max` maximal_mu_depth_to sdepth E ψ2
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ1 ∪ free_evars ψ2
wfψ1: well_formed ψ1 = true
H: size' ψ1 ≤ sz
wfψ2: well_formed ψ2 = true
H0: size' ψ2 ≤ sz
Hef1: fresh_evars el
  (free_evars ψ1 ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hsf1: fresh_svars sl
  (free_svars ψ1 ∪ free_svars p ∪ free_svars q)
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]]
using gpi
Hef2: fresh_evars el
  (free_evars ψ2 ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hsf2: fresh_svars sl
  (free_svars ψ2 ∪ free_svars p ∪ free_svars q)
ProofInfoLe
  (ExGen := evs, SVSubst := svs,
   KT := mu_in_evar_path E ψ2 sdepth) gpi clear - i' pile.
Σ: Signature
E: evar
sdepth: nat
ψ1, ψ2: Pattern
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (ψ1 $ ψ2) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
ProofInfoLe
  (ExGen := evs, SVSubst := svs,
   KT := mu_in_evar_path E ψ2 sdepth) gpi try_solve_pile.
Σ: Signature
E: evar
sdepth: nat
ψ1, ψ2: Pattern
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (ψ1 $ ψ2) sdepth: ProofInfo
H: evs ⊆ pi_generalized_evars gpi
H0: svs ⊆ pi_substituted_svars gpi
H1: mu_in_evar_path E (ψ1 $ ψ2) sdepth ==>
pi_uses_kt gpi
pi_uses_kt
  (ExGen := evs, SVSubst := svs,
   KT := mu_in_evar_path E ψ2 sdepth) ==>
pi_uses_kt gpi
        cbn in *.
Σ: Signature
E: evar
sdepth: nat
ψ1, ψ2: Pattern
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (ψ1 $ ψ2) sdepth: ProofInfo
H: evs ⊆ pi_generalized_evars gpi
H0: svs ⊆ pi_substituted_svars gpi
H1: mu_in_evar_path E (ψ1 $ ψ2) sdepth ==>
pi_uses_kt gpi
mu_in_evar_path E ψ2 sdepth ==> pi_uses_kt gpi unfold mu_in_evar_path in *.
Σ: Signature
E: evar
sdepth: nat
ψ1, ψ2: Pattern
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := ~~
      (0 =? maximal_mu_depth_to sdepth E (ψ1 $ ψ2))%nat: ProofInfo
H: evs ⊆ pi_generalized_evars gpi
H0: svs ⊆ pi_substituted_svars gpi
H1: ~~
(0 =? maximal_mu_depth_to sdepth E (ψ1 $ ψ2))%nat ==>
pi_uses_kt gpi
~~ (0 =? maximal_mu_depth_to sdepth E ψ2)%nat ==>
pi_uses_kt gpi cbn in *.
Σ: Signature
E: evar
sdepth: nat
ψ1, ψ2: Pattern
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := ~~
      match
        maximal_mu_depth_to sdepth E ψ1
        `max` maximal_mu_depth_to sdepth E ψ2
      with
      | 0 => true
      | S _ => false
      end: ProofInfo
H: evs ⊆ pi_generalized_evars gpi
H0: svs ⊆ pi_substituted_svars gpi
H1: ~~
match
  maximal_mu_depth_to sdepth E ψ1
  `max` maximal_mu_depth_to sdepth E ψ2
with
| 0 => true
| S _ => false
end ==> pi_uses_kt gpi
~~
match maximal_mu_depth_to sdepth E ψ2 with
| 0 => true
| S _ => false
end ==> pi_uses_kt gpi
        do 2 case_match; cbn in *; auto.
Σ: Signature
E: evar
sdepth: nat
ψ1, ψ2: Pattern
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
n: nat
H3: maximal_mu_depth_to sdepth E ψ2 = S n
H2: maximal_mu_depth_to sdepth E ψ1 `max` S n = 0
i':= ExGen := evs, SVSubst := svs, KT := false: ProofInfo
H: evs ⊆ pi_generalized_evars gpi
H0: svs ⊆ pi_substituted_svars gpi
H1: true
pi_uses_kt gpi lia. }
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ1, ψ2: Pattern
wfψ: well_formed (ψ1 $ ψ2)
Hsz: S (size' ψ1 + size' ψ2) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (ψ1 $ ψ2) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ψ1 ∪ free_evars ψ2 ∪ free_evars p
   ∪ free_evars q ∪ {[E]})
Hel2: length el
≥ maximal_exists_depth_to edepth E ψ1
  `max` maximal_exists_depth_to edepth E ψ2
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars ψ1 ∪ free_svars ψ2 ∪ free_svars p
   ∪ free_svars q)
Hsl2: length sl
≥ maximal_mu_depth_to sdepth E ψ1
  `max` maximal_mu_depth_to sdepth E ψ2
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ1 ∪ free_evars ψ2
wfψ1: well_formed ψ1 = true
H: size' ψ1 ≤ sz
wfψ2: well_formed ψ2 = true
H0: size' ψ2 ≤ sz
Hef1: fresh_evars el
  (free_evars ψ1 ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hsf1: fresh_svars sl
  (free_svars ψ1 ∪ free_svars p ∪ free_svars q)
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]]
using gpi
Hef2: fresh_evars el
  (free_evars ψ2 ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hsf2: fresh_svars sl
  (free_svars ψ2 ∪ free_svars p ∪ free_svars q)
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]]
using gpi
Γ
⊢i ψ1^[[evar:E↦p]] $ ψ2^[[evar:E↦p]] <--->
   ψ1^[[evar:E↦q]] $ ψ2^[[evar:E↦q]] using gpi

      unshelve (eapply congruence_app); try assumption.
    }
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
wfψ: well_formed ⊥
Hsz: 1 ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E ⊥ sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ⊥ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ⊥
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars ⊥ ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ⊥
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ⊥
Γ ⊢i ⊥ <---> ⊥ using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ1, ψ2: Pattern
wfψ: well_formed (ψ1 ---> ψ2)
Hsz: S (size' ψ1 + size' ψ2) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (ψ1 ---> ψ2) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars (ψ1 ---> ψ2) ∪ free_evars p
   ∪ free_evars q ∪ {[E]})
Hel2: length el
≥ maximal_exists_depth_to edepth E (ψ1 ---> ψ2)
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars (ψ1 ---> ψ2) ∪ free_svars p
   ∪ free_svars q)
Hsl2: length sl
≥ maximal_mu_depth_to sdepth E (ψ1 ---> ψ2)
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars (ψ1 ---> ψ2)
Γ
⊢i (ψ1^[[evar:E↦p]] ---> ψ2^[[evar:E↦p]]) <--->
   (ψ1^[[evar:E↦q]] ---> ψ2^[[evar:E↦q]]) using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (ex , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (ex , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars (ex , ψ) ∪ free_evars p
   ∪ free_evars q ∪ {[E]})
Hel2: length el
≥ maximal_exists_depth_to edepth E (ex , ψ)
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars (ex , ψ) ∪ free_svars p
   ∪ free_svars q)
Hsl2: length sl
≥ maximal_mu_depth_to sdepth E (ex , ψ)
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars (ex , ψ)
Γ ⊢i (ex , ψ^[[evar:E↦p]]) <---> (ex , ψ^[[evar:E↦q]])
using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (mu , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars (mu , ψ) ∪ free_evars p
   ∪ free_evars q ∪ {[E]})
Hel2: length el
≥ maximal_exists_depth_to edepth E (mu , ψ)
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars (mu , ψ) ∪ free_svars p
   ∪ free_svars q)
Hsl2: length sl
≥ maximal_mu_depth_to sdepth E (mu , ψ)
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars (mu , ψ)
Γ ⊢i (mu , ψ^[[evar:E↦p]]) <---> (mu , ψ^[[evar:E↦q]])
using gpi
    {
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
wfψ: well_formed ⊥
Hsz: 1 ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E ⊥ sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ⊥ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ⊥
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars ⊥ ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ⊥
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ⊥
Γ ⊢i ⊥ <---> ⊥ using gpi
      useBasicReasoning.
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
wfψ: well_formed ⊥
Hsz: 1 ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E ⊥ sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ⊥ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ⊥
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars ⊥ ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ⊥
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ⊥
Γ ⊢i ⊥ <---> ⊥ using BasicReasoning
      apply pf_iff_equiv_refl.
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
wfψ: well_formed ⊥
Hsz: 1 ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E ⊥ sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ⊥ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ⊥
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars ⊥ ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ⊥
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ⊥
well_formed ⊥
      abstract (wf_auto2).
    }
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ1, ψ2: Pattern
wfψ: well_formed (ψ1 ---> ψ2)
Hsz: S (size' ψ1 + size' ψ2) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (ψ1 ---> ψ2) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars (ψ1 ---> ψ2) ∪ free_evars p
   ∪ free_evars q ∪ {[E]})
Hel2: length el
≥ maximal_exists_depth_to edepth E (ψ1 ---> ψ2)
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars (ψ1 ---> ψ2) ∪ free_svars p
   ∪ free_svars q)
Hsl2: length sl
≥ maximal_mu_depth_to sdepth E (ψ1 ---> ψ2)
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars (ψ1 ---> ψ2)
Γ
⊢i (ψ1^[[evar:E↦p]] ---> ψ2^[[evar:E↦p]]) <--->
   (ψ1^[[evar:E↦q]] ---> ψ2^[[evar:E↦q]]) using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (ex , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (ex , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars (ex , ψ) ∪ free_evars p
   ∪ free_evars q ∪ {[E]})
Hel2: length el
≥ maximal_exists_depth_to edepth E (ex , ψ)
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars (ex , ψ) ∪ free_svars p
   ∪ free_svars q)
Hsl2: length sl
≥ maximal_mu_depth_to sdepth E (ex , ψ)
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars (ex , ψ)
Γ ⊢i (ex , ψ^[[evar:E↦p]]) <---> (ex , ψ^[[evar:E↦q]])
using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (mu , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars (mu , ψ) ∪ free_evars p
   ∪ free_evars q ∪ {[E]})
Hel2: length el
≥ maximal_exists_depth_to edepth E (mu , ψ)
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars (mu , ψ) ∪ free_svars p
   ∪ free_svars q)
Hsl2: length sl
≥ maximal_mu_depth_to sdepth E (mu , ψ)
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars (mu , ψ)
Γ ⊢i (mu , ψ^[[evar:E↦p]]) <---> (mu , ψ^[[evar:E↦q]])
using gpi
    {
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ1, ψ2: Pattern
wfψ: well_formed (ψ1 ---> ψ2)
Hsz: S (size' ψ1 + size' ψ2) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (ψ1 ---> ψ2) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars (ψ1 ---> ψ2) ∪ free_evars p
   ∪ free_evars q ∪ {[E]})
Hel2: length el
≥ maximal_exists_depth_to edepth E (ψ1 ---> ψ2)
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars (ψ1 ---> ψ2) ∪ free_svars p
   ∪ free_svars q)
Hsl2: length sl
≥ maximal_mu_depth_to sdepth E (ψ1 ---> ψ2)
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars (ψ1 ---> ψ2)
Γ
⊢i (ψ1^[[evar:E↦p]] ---> ψ2^[[evar:E↦p]]) <--->
   (ψ1^[[evar:E↦q]] ---> ψ2^[[evar:E↦q]]) using gpi
      assert (wfψ1 : well_formed ψ1 = true).
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ1, ψ2: Pattern
wfψ: well_formed (ψ1 ---> ψ2)
Hsz: S (size' ψ1 + size' ψ2) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (ψ1 ---> ψ2) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars (ψ1 ---> ψ2) ∪ free_evars p
   ∪ free_evars q ∪ {[E]})
Hel2: length el
≥ maximal_exists_depth_to edepth E (ψ1 ---> ψ2)
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars (ψ1 ---> ψ2) ∪ free_svars p
   ∪ free_svars q)
Hsl2: length sl
≥ maximal_mu_depth_to sdepth E (ψ1 ---> ψ2)
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars (ψ1 ---> ψ2)
well_formed ψ1 = true
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ1, ψ2: Pattern
wfψ: well_formed (ψ1 ---> ψ2)
Hsz: S (size' ψ1 + size' ψ2) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (ψ1 ---> ψ2) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars (ψ1 ---> ψ2) ∪ free_evars p
   ∪ free_evars q ∪ {[E]})
Hel2: length el
≥ maximal_exists_depth_to edepth E (ψ1 ---> ψ2)
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars (ψ1 ---> ψ2) ∪ free_svars p
   ∪ free_svars q)
Hsl2: length sl
≥ maximal_mu_depth_to sdepth E (ψ1 ---> ψ2)
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars (ψ1 ---> ψ2)
wfψ1: well_formed ψ1 = true
Γ
⊢i (ψ1^[[evar:E↦p]] ---> ψ2^[[evar:E↦p]]) <--->
   (ψ1^[[evar:E↦q]] ---> ψ2^[[evar:E↦q]]) using gpi
      {
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ1, ψ2: Pattern
wfψ: well_formed (ψ1 ---> ψ2)
Hsz: S (size' ψ1 + size' ψ2) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (ψ1 ---> ψ2) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars (ψ1 ---> ψ2) ∪ free_evars p
   ∪ free_evars q ∪ {[E]})
Hel2: length el
≥ maximal_exists_depth_to edepth E (ψ1 ---> ψ2)
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars (ψ1 ---> ψ2) ∪ free_svars p
   ∪ free_svars q)
Hsl2: length sl
≥ maximal_mu_depth_to sdepth E (ψ1 ---> ψ2)
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars (ψ1 ---> ψ2)
well_formed ψ1 = true clear -wfψ.
Σ: Signature
ψ1, ψ2: Pattern
wfψ: well_formed (ψ1 ---> ψ2)
well_formed ψ1 = true abstract (wf_auto2). }
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ1, ψ2: Pattern
wfψ: well_formed (ψ1 ---> ψ2)
Hsz: S (size' ψ1 + size' ψ2) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (ψ1 ---> ψ2) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars (ψ1 ---> ψ2) ∪ free_evars p
   ∪ free_evars q ∪ {[E]})
Hel2: length el
≥ maximal_exists_depth_to edepth E (ψ1 ---> ψ2)
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars (ψ1 ---> ψ2) ∪ free_svars p
   ∪ free_svars q)
Hsl2: length sl
≥ maximal_mu_depth_to sdepth E (ψ1 ---> ψ2)
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars (ψ1 ---> ψ2)
wfψ1: well_formed ψ1 = true
Γ
⊢i (ψ1^[[evar:E↦p]] ---> ψ2^[[evar:E↦p]]) <--->
   (ψ1^[[evar:E↦q]] ---> ψ2^[[evar:E↦q]]) using gpi
      assert (size' ψ1 <= sz) by abstract(lia).
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ1, ψ2: Pattern
wfψ: well_formed (ψ1 ---> ψ2)
Hsz: S (size' ψ1 + size' ψ2) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (ψ1 ---> ψ2) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars (ψ1 ---> ψ2) ∪ free_evars p
   ∪ free_evars q ∪ {[E]})
Hel2: length el
≥ maximal_exists_depth_to edepth E (ψ1 ---> ψ2)
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars (ψ1 ---> ψ2) ∪ free_svars p
   ∪ free_svars q)
Hsl2: length sl
≥ maximal_mu_depth_to sdepth E (ψ1 ---> ψ2)
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars (ψ1 ---> ψ2)
wfψ1: well_formed ψ1 = true
H: size' ψ1 ≤ sz
Γ
⊢i (ψ1^[[evar:E↦p]] ---> ψ2^[[evar:E↦p]]) <--->
   (ψ1^[[evar:E↦q]] ---> ψ2^[[evar:E↦q]]) using gpi
      assert (wfψ2 : well_formed ψ2 = true).
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ1, ψ2: Pattern
wfψ: well_formed (ψ1 ---> ψ2)
Hsz: S (size' ψ1 + size' ψ2) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (ψ1 ---> ψ2) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars (ψ1 ---> ψ2) ∪ free_evars p
   ∪ free_evars q ∪ {[E]})
Hel2: length el
≥ maximal_exists_depth_to edepth E (ψ1 ---> ψ2)
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars (ψ1 ---> ψ2) ∪ free_svars p
   ∪ free_svars q)
Hsl2: length sl
≥ maximal_mu_depth_to sdepth E (ψ1 ---> ψ2)
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars (ψ1 ---> ψ2)
wfψ1: well_formed ψ1 = true
H: size' ψ1 ≤ sz
well_formed ψ2 = true
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ1, ψ2: Pattern
wfψ: well_formed (ψ1 ---> ψ2)
Hsz: S (size' ψ1 + size' ψ2) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (ψ1 ---> ψ2) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars (ψ1 ---> ψ2) ∪ free_evars p
   ∪ free_evars q ∪ {[E]})
Hel2: length el
≥ maximal_exists_depth_to edepth E (ψ1 ---> ψ2)
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars (ψ1 ---> ψ2) ∪ free_svars p
   ∪ free_svars q)
Hsl2: length sl
≥ maximal_mu_depth_to sdepth E (ψ1 ---> ψ2)
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars (ψ1 ---> ψ2)
wfψ1: well_formed ψ1 = true
H: size' ψ1 ≤ sz
wfψ2: well_formed ψ2 = true
Γ
⊢i (ψ1^[[evar:E↦p]] ---> ψ2^[[evar:E↦p]]) <--->
   (ψ1^[[evar:E↦q]] ---> ψ2^[[evar:E↦q]]) using gpi
      {
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ1, ψ2: Pattern
wfψ: well_formed (ψ1 ---> ψ2)
Hsz: S (size' ψ1 + size' ψ2) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (ψ1 ---> ψ2) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars (ψ1 ---> ψ2) ∪ free_evars p
   ∪ free_evars q ∪ {[E]})
Hel2: length el
≥ maximal_exists_depth_to edepth E (ψ1 ---> ψ2)
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars (ψ1 ---> ψ2) ∪ free_svars p
   ∪ free_svars q)
Hsl2: length sl
≥ maximal_mu_depth_to sdepth E (ψ1 ---> ψ2)
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars (ψ1 ---> ψ2)
wfψ1: well_formed ψ1 = true
H: size' ψ1 ≤ sz
well_formed ψ2 = true clear -wfψ.
Σ: Signature
ψ1, ψ2: Pattern
wfψ: well_formed (ψ1 ---> ψ2)
well_formed ψ2 = true abstract (wf_auto2). }
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ1, ψ2: Pattern
wfψ: well_formed (ψ1 ---> ψ2)
Hsz: S (size' ψ1 + size' ψ2) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (ψ1 ---> ψ2) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars (ψ1 ---> ψ2) ∪ free_evars p
   ∪ free_evars q ∪ {[E]})
Hel2: length el
≥ maximal_exists_depth_to edepth E (ψ1 ---> ψ2)
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars (ψ1 ---> ψ2) ∪ free_svars p
   ∪ free_svars q)
Hsl2: length sl
≥ maximal_mu_depth_to sdepth E (ψ1 ---> ψ2)
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars (ψ1 ---> ψ2)
wfψ1: well_formed ψ1 = true
H: size' ψ1 ≤ sz
wfψ2: well_formed ψ2 = true
Γ
⊢i (ψ1^[[evar:E↦p]] ---> ψ2^[[evar:E↦p]]) <--->
   (ψ1^[[evar:E↦q]] ---> ψ2^[[evar:E↦q]]) using gpi
      assert (size' ψ2 <= sz) by abstract(lia).
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ1, ψ2: Pattern
wfψ: well_formed (ψ1 ---> ψ2)
Hsz: S (size' ψ1 + size' ψ2) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (ψ1 ---> ψ2) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars (ψ1 ---> ψ2) ∪ free_evars p
   ∪ free_evars q ∪ {[E]})
Hel2: length el
≥ maximal_exists_depth_to edepth E (ψ1 ---> ψ2)
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars (ψ1 ---> ψ2) ∪ free_svars p
   ∪ free_svars q)
Hsl2: length sl
≥ maximal_mu_depth_to sdepth E (ψ1 ---> ψ2)
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars (ψ1 ---> ψ2)
wfψ1: well_formed ψ1 = true
H: size' ψ1 ≤ sz
wfψ2: well_formed ψ2 = true
H0: size' ψ2 ≤ sz
Γ
⊢i (ψ1^[[evar:E↦p]] ---> ψ2^[[evar:E↦p]]) <--->
   (ψ1^[[evar:E↦q]] ---> ψ2^[[evar:E↦q]]) using gpi

      pose proof (Hef1 := fresh_evars_bigger (free_evars ψ1 ∪ free_evars p ∪ free_evars q ∪ {[E]}) Hel1 ltac:(set_solver)).
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ1, ψ2: Pattern
wfψ: well_formed (ψ1 ---> ψ2)
Hsz: S (size' ψ1 + size' ψ2) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (ψ1 ---> ψ2) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars (ψ1 ---> ψ2) ∪ free_evars p
   ∪ free_evars q ∪ {[E]})
Hel2: length el
≥ maximal_exists_depth_to edepth E (ψ1 ---> ψ2)
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars (ψ1 ---> ψ2) ∪ free_svars p
   ∪ free_svars q)
Hsl2: length sl
≥ maximal_mu_depth_to sdepth E (ψ1 ---> ψ2)
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars (ψ1 ---> ψ2)
wfψ1: well_formed ψ1 = true
H: size' ψ1 ≤ sz
wfψ2: well_formed ψ2 = true
H0: size' ψ2 ≤ sz
Hef1: fresh_evars el
  (free_evars ψ1 ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Γ
⊢i (ψ1^[[evar:E↦p]] ---> ψ2^[[evar:E↦p]]) <--->
   (ψ1^[[evar:E↦q]] ---> ψ2^[[evar:E↦q]]) using gpi
      
      pose proof (Hsf1 := fresh_svars_bigger (free_svars ψ1 ∪ free_svars p ∪ free_svars q) Hsl1 ltac:(set_solver)).
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ1, ψ2: Pattern
wfψ: well_formed (ψ1 ---> ψ2)
Hsz: S (size' ψ1 + size' ψ2) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (ψ1 ---> ψ2) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars (ψ1 ---> ψ2) ∪ free_evars p
   ∪ free_evars q ∪ {[E]})
Hel2: length el
≥ maximal_exists_depth_to edepth E (ψ1 ---> ψ2)
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars (ψ1 ---> ψ2) ∪ free_svars p
   ∪ free_svars q)
Hsl2: length sl
≥ maximal_mu_depth_to sdepth E (ψ1 ---> ψ2)
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars (ψ1 ---> ψ2)
wfψ1: well_formed ψ1 = true
H: size' ψ1 ≤ sz
wfψ2: well_formed ψ2 = true
H0: size' ψ2 ≤ sz
Hef1: fresh_evars el
  (free_evars ψ1 ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hsf1: fresh_svars sl
  (free_svars ψ1 ∪ free_svars p ∪ free_svars q)
Γ
⊢i (ψ1^[[evar:E↦p]] ---> ψ2^[[evar:E↦p]]) <--->
   (ψ1^[[evar:E↦q]] ---> ψ2^[[evar:E↦q]]) using gpi
      
      simpl in *.
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ1, ψ2: Pattern
wfψ: well_formed (ψ1 ---> ψ2)
Hsz: S (size' ψ1 + size' ψ2) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (ψ1 ---> ψ2) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ψ1 ∪ free_evars ψ2 ∪ free_evars p
   ∪ free_evars q ∪ {[E]})
Hel2: length el
≥ maximal_exists_depth_to edepth E ψ1
  `max` maximal_exists_depth_to edepth E ψ2
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars ψ1 ∪ free_svars ψ2 ∪ free_svars p
   ∪ free_svars q)
Hsl2: length sl
≥ maximal_mu_depth_to sdepth E ψ1
  `max` maximal_mu_depth_to sdepth E ψ2
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ1 ∪ free_evars ψ2
wfψ1: well_formed ψ1 = true
H: size' ψ1 ≤ sz
wfψ2: well_formed ψ2 = true
H0: size' ψ2 ≤ sz
Hef1: fresh_evars el
  (free_evars ψ1 ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hsf1: fresh_svars sl
  (free_svars ψ1 ∪ free_svars p ∪ free_svars q)
Γ
⊢i (ψ1^[[evar:E↦p]] ---> ψ2^[[evar:E↦p]]) <--->
   (ψ1^[[evar:E↦q]] ---> ψ2^[[evar:E↦q]]) using gpi
      unshelve (epose proof (pf₁ := IHsz edepth sdepth ψ1 ltac:(assumption) ltac:(assumption) evs svs gpi _ pf el Hef1 ltac:(lia) Hel3 sl Hsf1 ltac:(lia) Hsl3)).
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ1, ψ2: Pattern
wfψ: well_formed (ψ1 ---> ψ2)
Hsz: S (size' ψ1 + size' ψ2) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (ψ1 ---> ψ2) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ψ1 ∪ free_evars ψ2 ∪ free_evars p
   ∪ free_evars q ∪ {[E]})
Hel2: length el
≥ maximal_exists_depth_to edepth E ψ1
  `max` maximal_exists_depth_to edepth E ψ2
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars ψ1 ∪ free_svars ψ2 ∪ free_svars p
   ∪ free_svars q)
Hsl2: length sl
≥ maximal_mu_depth_to sdepth E ψ1
  `max` maximal_mu_depth_to sdepth E ψ2
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ1 ∪ free_evars ψ2
wfψ1: well_formed ψ1 = true
H: size' ψ1 ≤ sz
wfψ2: well_formed ψ2 = true
H0: size' ψ2 ≤ sz
Hef1: fresh_evars el
  (free_evars ψ1 ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hsf1: fresh_svars sl
  (free_svars ψ1 ∪ free_svars p ∪ free_svars q)
ProofInfoLe
  (ExGen := evs, SVSubst := svs,
   KT := mu_in_evar_path E ψ1 sdepth) gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ1, ψ2: Pattern
wfψ: well_formed (ψ1 ---> ψ2)
Hsz: S (size' ψ1 + size' ψ2) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (ψ1 ---> ψ2) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ψ1 ∪ free_evars ψ2 ∪ free_evars p
   ∪ free_evars q ∪ {[E]})
Hel2: length el
≥ maximal_exists_depth_to edepth E ψ1
  `max` maximal_exists_depth_to edepth E ψ2
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars ψ1 ∪ free_svars ψ2 ∪ free_svars p
   ∪ free_svars q)
Hsl2: length sl
≥ maximal_mu_depth_to sdepth E ψ1
  `max` maximal_mu_depth_to sdepth E ψ2
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ1 ∪ free_evars ψ2
wfψ1: well_formed ψ1 = true
H: size' ψ1 ≤ sz
wfψ2: well_formed ψ2 = true
H0: size' ψ2 ≤ sz
Hef1: fresh_evars el
  (free_evars ψ1 ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hsf1: fresh_svars sl
  (free_svars ψ1 ∪ free_svars p ∪ free_svars q)
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]]
using gpi
Γ
⊢i (ψ1^[[evar:E↦p]] ---> ψ2^[[evar:E↦p]]) <--->
   (ψ1^[[evar:E↦q]] ---> ψ2^[[evar:E↦q]]) using gpi
      {
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ1, ψ2: Pattern
wfψ: well_formed (ψ1 ---> ψ2)
Hsz: S (size' ψ1 + size' ψ2) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (ψ1 ---> ψ2) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ψ1 ∪ free_evars ψ2 ∪ free_evars p
   ∪ free_evars q ∪ {[E]})
Hel2: length el
≥ maximal_exists_depth_to edepth E ψ1
  `max` maximal_exists_depth_to edepth E ψ2
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars ψ1 ∪ free_svars ψ2 ∪ free_svars p
   ∪ free_svars q)
Hsl2: length sl
≥ maximal_mu_depth_to sdepth E ψ1
  `max` maximal_mu_depth_to sdepth E ψ2
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ1 ∪ free_evars ψ2
wfψ1: well_formed ψ1 = true
H: size' ψ1 ≤ sz
wfψ2: well_formed ψ2 = true
H0: size' ψ2 ≤ sz
Hef1: fresh_evars el
  (free_evars ψ1 ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hsf1: fresh_svars sl
  (free_svars ψ1 ∪ free_svars p ∪ free_svars q)
ProofInfoLe
  (ExGen := evs, SVSubst := svs,
   KT := mu_in_evar_path E ψ1 sdepth) gpi clear - i' pile.
Σ: Signature
E: evar
sdepth: nat
ψ1, ψ2: Pattern
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (ψ1 ---> ψ2) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
ProofInfoLe
  (ExGen := evs, SVSubst := svs,
   KT := mu_in_evar_path E ψ1 sdepth) gpi try_solve_pile.
Σ: Signature
E: evar
sdepth: nat
ψ1, ψ2: Pattern
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (ψ1 ---> ψ2) sdepth: ProofInfo
H: evs ⊆ pi_generalized_evars gpi
H0: svs ⊆ pi_substituted_svars gpi
H1: mu_in_evar_path E (ψ1 ---> ψ2) sdepth ==>
pi_uses_kt gpi
pi_uses_kt
  (ExGen := evs, SVSubst := svs,
   KT := mu_in_evar_path E ψ1 sdepth) ==>
pi_uses_kt gpi
        cbn in *.
Σ: Signature
E: evar
sdepth: nat
ψ1, ψ2: Pattern
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (ψ1 ---> ψ2) sdepth: ProofInfo
H: evs ⊆ pi_generalized_evars gpi
H0: svs ⊆ pi_substituted_svars gpi
H1: mu_in_evar_path E (ψ1 ---> ψ2) sdepth ==>
pi_uses_kt gpi
mu_in_evar_path E ψ1 sdepth ==> pi_uses_kt gpi unfold mu_in_evar_path in *.
Σ: Signature
E: evar
sdepth: nat
ψ1, ψ2: Pattern
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := ~~
      (0 =?
       maximal_mu_depth_to sdepth E (ψ1 ---> ψ2))%nat: ProofInfo
H: evs ⊆ pi_generalized_evars gpi
H0: svs ⊆ pi_substituted_svars gpi
H1: ~~
(0 =? maximal_mu_depth_to sdepth E (ψ1 ---> ψ2))%nat ==>
pi_uses_kt gpi
~~ (0 =? maximal_mu_depth_to sdepth E ψ1)%nat ==>
pi_uses_kt gpi cbn in *.
Σ: Signature
E: evar
sdepth: nat
ψ1, ψ2: Pattern
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := ~~
      match
        maximal_mu_depth_to sdepth E ψ1
        `max` maximal_mu_depth_to sdepth E ψ2
      with
      | 0 => true
      | S _ => false
      end: ProofInfo
H: evs ⊆ pi_generalized_evars gpi
H0: svs ⊆ pi_substituted_svars gpi
H1: ~~
match
  maximal_mu_depth_to sdepth E ψ1
  `max` maximal_mu_depth_to sdepth E ψ2
with
| 0 => true
| S _ => false
end ==> pi_uses_kt gpi
~~
match maximal_mu_depth_to sdepth E ψ1 with
| 0 => true
| S _ => false
end ==> pi_uses_kt gpi
        do 2 case_match; cbn in *; auto.
Σ: Signature
E: evar
sdepth: nat
ψ1, ψ2: Pattern
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
n: nat
H3: maximal_mu_depth_to sdepth E ψ1 = S n
H2: S n `max` maximal_mu_depth_to sdepth E ψ2 = 0
i':= ExGen := evs, SVSubst := svs, KT := false: ProofInfo
H: evs ⊆ pi_generalized_evars gpi
H0: svs ⊆ pi_substituted_svars gpi
H1: true
pi_uses_kt gpi lia. }
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ1, ψ2: Pattern
wfψ: well_formed (ψ1 ---> ψ2)
Hsz: S (size' ψ1 + size' ψ2) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (ψ1 ---> ψ2) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ψ1 ∪ free_evars ψ2 ∪ free_evars p
   ∪ free_evars q ∪ {[E]})
Hel2: length el
≥ maximal_exists_depth_to edepth E ψ1
  `max` maximal_exists_depth_to edepth E ψ2
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars ψ1 ∪ free_svars ψ2 ∪ free_svars p
   ∪ free_svars q)
Hsl2: length sl
≥ maximal_mu_depth_to sdepth E ψ1
  `max` maximal_mu_depth_to sdepth E ψ2
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ1 ∪ free_evars ψ2
wfψ1: well_formed ψ1 = true
H: size' ψ1 ≤ sz
wfψ2: well_formed ψ2 = true
H0: size' ψ2 ≤ sz
Hef1: fresh_evars el
  (free_evars ψ1 ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hsf1: fresh_svars sl
  (free_svars ψ1 ∪ free_svars p ∪ free_svars q)
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]]
using gpi
Γ
⊢i (ψ1^[[evar:E↦p]] ---> ψ2^[[evar:E↦p]]) <--->
   (ψ1^[[evar:E↦q]] ---> ψ2^[[evar:E↦q]]) using gpi

      epose proof (Hef2 := fresh_evars_bigger (free_evars ψ2 ∪ free_evars p ∪ free_evars q ∪ {[E]}) Hel1 ltac:(set_solver)).
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ1, ψ2: Pattern
wfψ: well_formed (ψ1 ---> ψ2)
Hsz: S (size' ψ1 + size' ψ2) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (ψ1 ---> ψ2) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ψ1 ∪ free_evars ψ2 ∪ free_evars p
   ∪ free_evars q ∪ {[E]})
Hel2: length el
≥ maximal_exists_depth_to edepth E ψ1
  `max` maximal_exists_depth_to edepth E ψ2
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars ψ1 ∪ free_svars ψ2 ∪ free_svars p
   ∪ free_svars q)
Hsl2: length sl
≥ maximal_mu_depth_to sdepth E ψ1
  `max` maximal_mu_depth_to sdepth E ψ2
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ1 ∪ free_evars ψ2
wfψ1: well_formed ψ1 = true
H: size' ψ1 ≤ sz
wfψ2: well_formed ψ2 = true
H0: size' ψ2 ≤ sz
Hef1: fresh_evars el
  (free_evars ψ1 ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hsf1: fresh_svars sl
  (free_svars ψ1 ∪ free_svars p ∪ free_svars q)
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]]
using gpi
Hef2: fresh_evars el
  (free_evars ψ2 ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Γ
⊢i (ψ1^[[evar:E↦p]] ---> ψ2^[[evar:E↦p]]) <--->
   (ψ1^[[evar:E↦q]] ---> ψ2^[[evar:E↦q]]) using gpi

      pose proof (Hsf2 := fresh_svars_bigger (free_svars ψ2 ∪ free_svars p ∪ free_svars q) Hsl1 ltac:(set_solver)).
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ1, ψ2: Pattern
wfψ: well_formed (ψ1 ---> ψ2)
Hsz: S (size' ψ1 + size' ψ2) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (ψ1 ---> ψ2) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ψ1 ∪ free_evars ψ2 ∪ free_evars p
   ∪ free_evars q ∪ {[E]})
Hel2: length el
≥ maximal_exists_depth_to edepth E ψ1
  `max` maximal_exists_depth_to edepth E ψ2
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars ψ1 ∪ free_svars ψ2 ∪ free_svars p
   ∪ free_svars q)
Hsl2: length sl
≥ maximal_mu_depth_to sdepth E ψ1
  `max` maximal_mu_depth_to sdepth E ψ2
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ1 ∪ free_evars ψ2
wfψ1: well_formed ψ1 = true
H: size' ψ1 ≤ sz
wfψ2: well_formed ψ2 = true
H0: size' ψ2 ≤ sz
Hef1: fresh_evars el
  (free_evars ψ1 ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hsf1: fresh_svars sl
  (free_svars ψ1 ∪ free_svars p ∪ free_svars q)
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]]
using gpi
Hef2: fresh_evars el
  (free_evars ψ2 ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hsf2: fresh_svars sl
  (free_svars ψ2 ∪ free_svars p ∪ free_svars q)
Γ
⊢i (ψ1^[[evar:E↦p]] ---> ψ2^[[evar:E↦p]]) <--->
   (ψ1^[[evar:E↦q]] ---> ψ2^[[evar:E↦q]]) using gpi

      unshelve(epose proof (pf₂ := IHsz edepth sdepth ψ2 ltac:(assumption) ltac:(assumption) evs svs gpi _ pf el Hef2 ltac:(lia) Hel3 sl Hsf2 ltac:(lia) Hsl3)).
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ1, ψ2: Pattern
wfψ: well_formed (ψ1 ---> ψ2)
Hsz: S (size' ψ1 + size' ψ2) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (ψ1 ---> ψ2) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ψ1 ∪ free_evars ψ2 ∪ free_evars p
   ∪ free_evars q ∪ {[E]})
Hel2: length el
≥ maximal_exists_depth_to edepth E ψ1
  `max` maximal_exists_depth_to edepth E ψ2
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars ψ1 ∪ free_svars ψ2 ∪ free_svars p
   ∪ free_svars q)
Hsl2: length sl
≥ maximal_mu_depth_to sdepth E ψ1
  `max` maximal_mu_depth_to sdepth E ψ2
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ1 ∪ free_evars ψ2
wfψ1: well_formed ψ1 = true
H: size' ψ1 ≤ sz
wfψ2: well_formed ψ2 = true
H0: size' ψ2 ≤ sz
Hef1: fresh_evars el
  (free_evars ψ1 ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hsf1: fresh_svars sl
  (free_svars ψ1 ∪ free_svars p ∪ free_svars q)
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]]
using gpi
Hef2: fresh_evars el
  (free_evars ψ2 ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hsf2: fresh_svars sl
  (free_svars ψ2 ∪ free_svars p ∪ free_svars q)
ProofInfoLe
  (ExGen := evs, SVSubst := svs,
   KT := mu_in_evar_path E ψ2 sdepth) gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ1, ψ2: Pattern
wfψ: well_formed (ψ1 ---> ψ2)
Hsz: S (size' ψ1 + size' ψ2) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (ψ1 ---> ψ2) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ψ1 ∪ free_evars ψ2 ∪ free_evars p
   ∪ free_evars q ∪ {[E]})
Hel2: length el
≥ maximal_exists_depth_to edepth E ψ1
  `max` maximal_exists_depth_to edepth E ψ2
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars ψ1 ∪ free_svars ψ2 ∪ free_svars p
   ∪ free_svars q)
Hsl2: length sl
≥ maximal_mu_depth_to sdepth E ψ1
  `max` maximal_mu_depth_to sdepth E ψ2
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ1 ∪ free_evars ψ2
wfψ1: well_formed ψ1 = true
H: size' ψ1 ≤ sz
wfψ2: well_formed ψ2 = true
H0: size' ψ2 ≤ sz
Hef1: fresh_evars el
  (free_evars ψ1 ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hsf1: fresh_svars sl
  (free_svars ψ1 ∪ free_svars p ∪ free_svars q)
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]]
using gpi
Hef2: fresh_evars el
  (free_evars ψ2 ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hsf2: fresh_svars sl
  (free_svars ψ2 ∪ free_svars p ∪ free_svars q)
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]]
using gpi
Γ
⊢i (ψ1^[[evar:E↦p]] ---> ψ2^[[evar:E↦p]]) <--->
   (ψ1^[[evar:E↦q]] ---> ψ2^[[evar:E↦q]]) using gpi
      {
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ1, ψ2: Pattern
wfψ: well_formed (ψ1 ---> ψ2)
Hsz: S (size' ψ1 + size' ψ2) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (ψ1 ---> ψ2) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ψ1 ∪ free_evars ψ2 ∪ free_evars p
   ∪ free_evars q ∪ {[E]})
Hel2: length el
≥ maximal_exists_depth_to edepth E ψ1
  `max` maximal_exists_depth_to edepth E ψ2
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars ψ1 ∪ free_svars ψ2 ∪ free_svars p
   ∪ free_svars q)
Hsl2: length sl
≥ maximal_mu_depth_to sdepth E ψ1
  `max` maximal_mu_depth_to sdepth E ψ2
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ1 ∪ free_evars ψ2
wfψ1: well_formed ψ1 = true
H: size' ψ1 ≤ sz
wfψ2: well_formed ψ2 = true
H0: size' ψ2 ≤ sz
Hef1: fresh_evars el
  (free_evars ψ1 ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hsf1: fresh_svars sl
  (free_svars ψ1 ∪ free_svars p ∪ free_svars q)
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]]
using gpi
Hef2: fresh_evars el
  (free_evars ψ2 ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hsf2: fresh_svars sl
  (free_svars ψ2 ∪ free_svars p ∪ free_svars q)
ProofInfoLe
  (ExGen := evs, SVSubst := svs,
   KT := mu_in_evar_path E ψ2 sdepth) gpi clear - i' pile.
Σ: Signature
E: evar
sdepth: nat
ψ1, ψ2: Pattern
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (ψ1 ---> ψ2) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
ProofInfoLe
  (ExGen := evs, SVSubst := svs,
   KT := mu_in_evar_path E ψ2 sdepth) gpi try_solve_pile.
Σ: Signature
E: evar
sdepth: nat
ψ1, ψ2: Pattern
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (ψ1 ---> ψ2) sdepth: ProofInfo
H: evs ⊆ pi_generalized_evars gpi
H0: svs ⊆ pi_substituted_svars gpi
H1: mu_in_evar_path E (ψ1 ---> ψ2) sdepth ==>
pi_uses_kt gpi
pi_uses_kt
  (ExGen := evs, SVSubst := svs,
   KT := mu_in_evar_path E ψ2 sdepth) ==>
pi_uses_kt gpi
        cbn in *.
Σ: Signature
E: evar
sdepth: nat
ψ1, ψ2: Pattern
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (ψ1 ---> ψ2) sdepth: ProofInfo
H: evs ⊆ pi_generalized_evars gpi
H0: svs ⊆ pi_substituted_svars gpi
H1: mu_in_evar_path E (ψ1 ---> ψ2) sdepth ==>
pi_uses_kt gpi
mu_in_evar_path E ψ2 sdepth ==> pi_uses_kt gpi unfold mu_in_evar_path in *.
Σ: Signature
E: evar
sdepth: nat
ψ1, ψ2: Pattern
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := ~~
      (0 =?
       maximal_mu_depth_to sdepth E (ψ1 ---> ψ2))%nat: ProofInfo
H: evs ⊆ pi_generalized_evars gpi
H0: svs ⊆ pi_substituted_svars gpi
H1: ~~
(0 =? maximal_mu_depth_to sdepth E (ψ1 ---> ψ2))%nat ==>
pi_uses_kt gpi
~~ (0 =? maximal_mu_depth_to sdepth E ψ2)%nat ==>
pi_uses_kt gpi cbn in *.
Σ: Signature
E: evar
sdepth: nat
ψ1, ψ2: Pattern
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := ~~
      match
        maximal_mu_depth_to sdepth E ψ1
        `max` maximal_mu_depth_to sdepth E ψ2
      with
      | 0 => true
      | S _ => false
      end: ProofInfo
H: evs ⊆ pi_generalized_evars gpi
H0: svs ⊆ pi_substituted_svars gpi
H1: ~~
match
  maximal_mu_depth_to sdepth E ψ1
  `max` maximal_mu_depth_to sdepth E ψ2
with
| 0 => true
| S _ => false
end ==> pi_uses_kt gpi
~~
match maximal_mu_depth_to sdepth E ψ2 with
| 0 => true
| S _ => false
end ==> pi_uses_kt gpi
        do 2 case_match; cbn in *; auto.
Σ: Signature
E: evar
sdepth: nat
ψ1, ψ2: Pattern
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
n: nat
H3: maximal_mu_depth_to sdepth E ψ2 = S n
H2: maximal_mu_depth_to sdepth E ψ1 `max` S n = 0
i':= ExGen := evs, SVSubst := svs, KT := false: ProofInfo
H: evs ⊆ pi_generalized_evars gpi
H0: svs ⊆ pi_substituted_svars gpi
H1: true
pi_uses_kt gpi lia. }
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ1, ψ2: Pattern
wfψ: well_formed (ψ1 ---> ψ2)
Hsz: S (size' ψ1 + size' ψ2) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (ψ1 ---> ψ2) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ψ1 ∪ free_evars ψ2 ∪ free_evars p
   ∪ free_evars q ∪ {[E]})
Hel2: length el
≥ maximal_exists_depth_to edepth E ψ1
  `max` maximal_exists_depth_to edepth E ψ2
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars ψ1 ∪ free_svars ψ2 ∪ free_svars p
   ∪ free_svars q)
Hsl2: length sl
≥ maximal_mu_depth_to sdepth E ψ1
  `max` maximal_mu_depth_to sdepth E ψ2
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ1 ∪ free_evars ψ2
wfψ1: well_formed ψ1 = true
H: size' ψ1 ≤ sz
wfψ2: well_formed ψ2 = true
H0: size' ψ2 ≤ sz
Hef1: fresh_evars el
  (free_evars ψ1 ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hsf1: fresh_svars sl
  (free_svars ψ1 ∪ free_svars p ∪ free_svars q)
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]]
using gpi
Hef2: fresh_evars el
  (free_evars ψ2 ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hsf2: fresh_svars sl
  (free_svars ψ2 ∪ free_svars p ∪ free_svars q)
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]]
using gpi
Γ
⊢i (ψ1^[[evar:E↦p]] ---> ψ2^[[evar:E↦p]]) <--->
   (ψ1^[[evar:E↦q]] ---> ψ2^[[evar:E↦q]]) using gpi

      apply prf_equiv_of_impl_of_equiv.
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ1, ψ2: Pattern
wfψ: well_formed (ψ1 ---> ψ2)
Hsz: S (size' ψ1 + size' ψ2) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (ψ1 ---> ψ2) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ψ1 ∪ free_evars ψ2 ∪ free_evars p
   ∪ free_evars q ∪ {[E]})
Hel2: length el
≥ maximal_exists_depth_to edepth E ψ1
  `max` maximal_exists_depth_to edepth E ψ2
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars ψ1 ∪ free_svars ψ2 ∪ free_svars p
   ∪ free_svars q)
Hsl2: length sl
≥ maximal_mu_depth_to sdepth E ψ1
  `max` maximal_mu_depth_to sdepth E ψ2
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ1 ∪ free_evars ψ2
wfψ1: well_formed ψ1 = true
H: size' ψ1 ≤ sz
wfψ2: well_formed ψ2 = true
H0: size' ψ2 ≤ sz
Hef1: fresh_evars el
  (free_evars ψ1 ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hsf1: fresh_svars sl
  (free_svars ψ1 ∪ free_svars p ∪ free_svars q)
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]]
using gpi
Hef2: fresh_evars el
  (free_evars ψ2 ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hsf2: fresh_svars sl
  (free_svars ψ2 ∪ free_svars p ∪ free_svars q)
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]]
using gpi
well_formed ψ1^[[evar:E↦p]] = true
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ1, ψ2: Pattern
wfψ: well_formed (ψ1 ---> ψ2)
Hsz: S (size' ψ1 + size' ψ2) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (ψ1 ---> ψ2) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ψ1 ∪ free_evars ψ2 ∪ free_evars p
   ∪ free_evars q ∪ {[E]})
Hel2: length el
≥ maximal_exists_depth_to edepth E ψ1
  `max` maximal_exists_depth_to edepth E ψ2
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars ψ1 ∪ free_svars ψ2 ∪ free_svars p
   ∪ free_svars q)
Hsl2: length sl
≥ maximal_mu_depth_to sdepth E ψ1
  `max` maximal_mu_depth_to sdepth E ψ2
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ1 ∪ free_evars ψ2
wfψ1: well_formed ψ1 = true
H: size' ψ1 ≤ sz
wfψ2: well_formed ψ2 = true
H0: size' ψ2 ≤ sz
Hef1: fresh_evars el
  (free_evars ψ1 ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hsf1: fresh_svars sl
  (free_svars ψ1 ∪ free_svars p ∪ free_svars q)
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]]
using gpi
Hef2: fresh_evars el
  (free_evars ψ2 ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hsf2: fresh_svars sl
  (free_svars ψ2 ∪ free_svars p ∪ free_svars q)
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]]
using gpi
well_formed ψ2^[[evar:E↦p]] = true
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ1, ψ2: Pattern
wfψ: well_formed (ψ1 ---> ψ2)
Hsz: S (size' ψ1 + size' ψ2) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (ψ1 ---> ψ2) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ψ1 ∪ free_evars ψ2 ∪ free_evars p
   ∪ free_evars q ∪ {[E]})
Hel2: length el
≥ maximal_exists_depth_to edepth E ψ1
  `max` maximal_exists_depth_to edepth E ψ2
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars ψ1 ∪ free_svars ψ2 ∪ free_svars p
   ∪ free_svars q)
Hsl2: length sl
≥ maximal_mu_depth_to sdepth E ψ1
  `max` maximal_mu_depth_to sdepth E ψ2
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ1 ∪ free_evars ψ2
wfψ1: well_formed ψ1 = true
H: size' ψ1 ≤ sz
wfψ2: well_formed ψ2 = true
H0: size' ψ2 ≤ sz
Hef1: fresh_evars el
  (free_evars ψ1 ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hsf1: fresh_svars sl
  (free_svars ψ1 ∪ free_svars p ∪ free_svars q)
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]]
using gpi
Hef2: fresh_evars el
  (free_evars ψ2 ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hsf2: fresh_svars sl
  (free_svars ψ2 ∪ free_svars p ∪ free_svars q)
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]]
using gpi
well_formed ψ1^[[evar:E↦q]] = true
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ1, ψ2: Pattern
wfψ: well_formed (ψ1 ---> ψ2)
Hsz: S (size' ψ1 + size' ψ2) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (ψ1 ---> ψ2) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ψ1 ∪ free_evars ψ2 ∪ free_evars p
   ∪ free_evars q ∪ {[E]})
Hel2: length el
≥ maximal_exists_depth_to edepth E ψ1
  `max` maximal_exists_depth_to edepth E ψ2
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars ψ1 ∪ free_svars ψ2 ∪ free_svars p
   ∪ free_svars q)
Hsl2: length sl
≥ maximal_mu_depth_to sdepth E ψ1
  `max` maximal_mu_depth_to sdepth E ψ2
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ1 ∪ free_evars ψ2
wfψ1: well_formed ψ1 = true
H: size' ψ1 ≤ sz
wfψ2: well_formed ψ2 = true
H0: size' ψ2 ≤ sz
Hef1: fresh_evars el
  (free_evars ψ1 ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hsf1: fresh_svars sl
  (free_svars ψ1 ∪ free_svars p ∪ free_svars q)
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]]
using gpi
Hef2: fresh_evars el
  (free_evars ψ2 ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hsf2: fresh_svars sl
  (free_svars ψ2 ∪ free_svars p ∪ free_svars q)
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]]
using gpi
well_formed ψ2^[[evar:E↦q]] = true
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ1, ψ2: Pattern
wfψ: well_formed (ψ1 ---> ψ2)
Hsz: S (size' ψ1 + size' ψ2) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (ψ1 ---> ψ2) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ψ1 ∪ free_evars ψ2 ∪ free_evars p
   ∪ free_evars q ∪ {[E]})
Hel2: length el
≥ maximal_exists_depth_to edepth E ψ1
  `max` maximal_exists_depth_to edepth E ψ2
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars ψ1 ∪ free_svars ψ2 ∪ free_svars p
   ∪ free_svars q)
Hsl2: length sl
≥ maximal_mu_depth_to sdepth E ψ1
  `max` maximal_mu_depth_to sdepth E ψ2
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ1 ∪ free_evars ψ2
wfψ1: well_formed ψ1 = true
H: size' ψ1 ≤ sz
wfψ2: well_formed ψ2 = true
H0: size' ψ2 ≤ sz
Hef1: fresh_evars el
  (free_evars ψ1 ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hsf1: fresh_svars sl
  (free_svars ψ1 ∪ free_svars p ∪ free_svars q)
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]]
using gpi
Hef2: fresh_evars el
  (free_evars ψ2 ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hsf2: fresh_svars sl
  (free_svars ψ2 ∪ free_svars p ∪ free_svars q)
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]]
using gpi
Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]] using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ1, ψ2: Pattern
wfψ: well_formed (ψ1 ---> ψ2)
Hsz: S (size' ψ1 + size' ψ2) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (ψ1 ---> ψ2) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ψ1 ∪ free_evars ψ2 ∪ free_evars p
   ∪ free_evars q ∪ {[E]})
Hel2: length el
≥ maximal_exists_depth_to edepth E ψ1
  `max` maximal_exists_depth_to edepth E ψ2
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars ψ1 ∪ free_svars ψ2 ∪ free_svars p
   ∪ free_svars q)
Hsl2: length sl
≥ maximal_mu_depth_to sdepth E ψ1
  `max` maximal_mu_depth_to sdepth E ψ2
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ1 ∪ free_evars ψ2
wfψ1: well_formed ψ1 = true
H: size' ψ1 ≤ sz
wfψ2: well_formed ψ2 = true
H0: size' ψ2 ≤ sz
Hef1: fresh_evars el
  (free_evars ψ1 ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hsf1: fresh_svars sl
  (free_svars ψ1 ∪ free_svars p ∪ free_svars q)
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]]
using gpi
Hef2: fresh_evars el
  (free_evars ψ2 ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hsf2: fresh_svars sl
  (free_svars ψ2 ∪ free_svars p ∪ free_svars q)
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]]
using gpi
Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]] using gpi
      {
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ1, ψ2: Pattern
wfψ: well_formed (ψ1 ---> ψ2)
Hsz: S (size' ψ1 + size' ψ2) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (ψ1 ---> ψ2) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ψ1 ∪ free_evars ψ2 ∪ free_evars p
   ∪ free_evars q ∪ {[E]})
Hel2: length el
≥ maximal_exists_depth_to edepth E ψ1
  `max` maximal_exists_depth_to edepth E ψ2
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars ψ1 ∪ free_svars ψ2 ∪ free_svars p
   ∪ free_svars q)
Hsl2: length sl
≥ maximal_mu_depth_to sdepth E ψ1
  `max` maximal_mu_depth_to sdepth E ψ2
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ1 ∪ free_evars ψ2
wfψ1: well_formed ψ1 = true
H: size' ψ1 ≤ sz
wfψ2: well_formed ψ2 = true
H0: size' ψ2 ≤ sz
Hef1: fresh_evars el
  (free_evars ψ1 ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hsf1: fresh_svars sl
  (free_svars ψ1 ∪ free_svars p ∪ free_svars q)
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]]
using gpi
Hef2: fresh_evars el
  (free_evars ψ2 ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hsf2: fresh_svars sl
  (free_svars ψ2 ∪ free_svars p ∪ free_svars q)
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]]
using gpi
well_formed ψ1^[[evar:E↦p]] = true abstract (wf_auto2). }
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ1, ψ2: Pattern
wfψ: well_formed (ψ1 ---> ψ2)
Hsz: S (size' ψ1 + size' ψ2) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (ψ1 ---> ψ2) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ψ1 ∪ free_evars ψ2 ∪ free_evars p
   ∪ free_evars q ∪ {[E]})
Hel2: length el
≥ maximal_exists_depth_to edepth E ψ1
  `max` maximal_exists_depth_to edepth E ψ2
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars ψ1 ∪ free_svars ψ2 ∪ free_svars p
   ∪ free_svars q)
Hsl2: length sl
≥ maximal_mu_depth_to sdepth E ψ1
  `max` maximal_mu_depth_to sdepth E ψ2
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ1 ∪ free_evars ψ2
wfψ1: well_formed ψ1 = true
H: size' ψ1 ≤ sz
wfψ2: well_formed ψ2 = true
H0: size' ψ2 ≤ sz
Hef1: fresh_evars el
  (free_evars ψ1 ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hsf1: fresh_svars sl
  (free_svars ψ1 ∪ free_svars p ∪ free_svars q)
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]]
using gpi
Hef2: fresh_evars el
  (free_evars ψ2 ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hsf2: fresh_svars sl
  (free_svars ψ2 ∪ free_svars p ∪ free_svars q)
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]]
using gpi
well_formed ψ2^[[evar:E↦p]] = true
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ1, ψ2: Pattern
wfψ: well_formed (ψ1 ---> ψ2)
Hsz: S (size' ψ1 + size' ψ2) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (ψ1 ---> ψ2) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ψ1 ∪ free_evars ψ2 ∪ free_evars p
   ∪ free_evars q ∪ {[E]})
Hel2: length el
≥ maximal_exists_depth_to edepth E ψ1
  `max` maximal_exists_depth_to edepth E ψ2
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars ψ1 ∪ free_svars ψ2 ∪ free_svars p
   ∪ free_svars q)
Hsl2: length sl
≥ maximal_mu_depth_to sdepth E ψ1
  `max` maximal_mu_depth_to sdepth E ψ2
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ1 ∪ free_evars ψ2
wfψ1: well_formed ψ1 = true
H: size' ψ1 ≤ sz
wfψ2: well_formed ψ2 = true
H0: size' ψ2 ≤ sz
Hef1: fresh_evars el
  (free_evars ψ1 ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hsf1: fresh_svars sl
  (free_svars ψ1 ∪ free_svars p ∪ free_svars q)
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]]
using gpi
Hef2: fresh_evars el
  (free_evars ψ2 ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hsf2: fresh_svars sl
  (free_svars ψ2 ∪ free_svars p ∪ free_svars q)
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]]
using gpi
well_formed ψ1^[[evar:E↦q]] = true
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ1, ψ2: Pattern
wfψ: well_formed (ψ1 ---> ψ2)
Hsz: S (size' ψ1 + size' ψ2) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (ψ1 ---> ψ2) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ψ1 ∪ free_evars ψ2 ∪ free_evars p
   ∪ free_evars q ∪ {[E]})
Hel2: length el
≥ maximal_exists_depth_to edepth E ψ1
  `max` maximal_exists_depth_to edepth E ψ2
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars ψ1 ∪ free_svars ψ2 ∪ free_svars p
   ∪ free_svars q)
Hsl2: length sl
≥ maximal_mu_depth_to sdepth E ψ1
  `max` maximal_mu_depth_to sdepth E ψ2
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ1 ∪ free_evars ψ2
wfψ1: well_formed ψ1 = true
H: size' ψ1 ≤ sz
wfψ2: well_formed ψ2 = true
H0: size' ψ2 ≤ sz
Hef1: fresh_evars el
  (free_evars ψ1 ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hsf1: fresh_svars sl
  (free_svars ψ1 ∪ free_svars p ∪ free_svars q)
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]]
using gpi
Hef2: fresh_evars el
  (free_evars ψ2 ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hsf2: fresh_svars sl
  (free_svars ψ2 ∪ free_svars p ∪ free_svars q)
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]]
using gpi
well_formed ψ2^[[evar:E↦q]] = true
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ1, ψ2: Pattern
wfψ: well_formed (ψ1 ---> ψ2)
Hsz: S (size' ψ1 + size' ψ2) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (ψ1 ---> ψ2) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ψ1 ∪ free_evars ψ2 ∪ free_evars p
   ∪ free_evars q ∪ {[E]})
Hel2: length el
≥ maximal_exists_depth_to edepth E ψ1
  `max` maximal_exists_depth_to edepth E ψ2
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars ψ1 ∪ free_svars ψ2 ∪ free_svars p
   ∪ free_svars q)
Hsl2: length sl
≥ maximal_mu_depth_to sdepth E ψ1
  `max` maximal_mu_depth_to sdepth E ψ2
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ1 ∪ free_evars ψ2
wfψ1: well_formed ψ1 = true
H: size' ψ1 ≤ sz
wfψ2: well_formed ψ2 = true
H0: size' ψ2 ≤ sz
Hef1: fresh_evars el
  (free_evars ψ1 ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hsf1: fresh_svars sl
  (free_svars ψ1 ∪ free_svars p ∪ free_svars q)
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]]
using gpi
Hef2: fresh_evars el
  (free_evars ψ2 ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hsf2: fresh_svars sl
  (free_svars ψ2 ∪ free_svars p ∪ free_svars q)
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]]
using gpi
Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]] using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ1, ψ2: Pattern
wfψ: well_formed (ψ1 ---> ψ2)
Hsz: S (size' ψ1 + size' ψ2) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (ψ1 ---> ψ2) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ψ1 ∪ free_evars ψ2 ∪ free_evars p
   ∪ free_evars q ∪ {[E]})
Hel2: length el
≥ maximal_exists_depth_to edepth E ψ1
  `max` maximal_exists_depth_to edepth E ψ2
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars ψ1 ∪ free_svars ψ2 ∪ free_svars p
   ∪ free_svars q)
Hsl2: length sl
≥ maximal_mu_depth_to sdepth E ψ1
  `max` maximal_mu_depth_to sdepth E ψ2
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ1 ∪ free_evars ψ2
wfψ1: well_formed ψ1 = true
H: size' ψ1 ≤ sz
wfψ2: well_formed ψ2 = true
H0: size' ψ2 ≤ sz
Hef1: fresh_evars el
  (free_evars ψ1 ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hsf1: fresh_svars sl
  (free_svars ψ1 ∪ free_svars p ∪ free_svars q)
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]]
using gpi
Hef2: fresh_evars el
  (free_evars ψ2 ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hsf2: fresh_svars sl
  (free_svars ψ2 ∪ free_svars p ∪ free_svars q)
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]]
using gpi
Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]] using gpi
      {
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ1, ψ2: Pattern
wfψ: well_formed (ψ1 ---> ψ2)
Hsz: S (size' ψ1 + size' ψ2) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (ψ1 ---> ψ2) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ψ1 ∪ free_evars ψ2 ∪ free_evars p
   ∪ free_evars q ∪ {[E]})
Hel2: length el
≥ maximal_exists_depth_to edepth E ψ1
  `max` maximal_exists_depth_to edepth E ψ2
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars ψ1 ∪ free_svars ψ2 ∪ free_svars p
   ∪ free_svars q)
Hsl2: length sl
≥ maximal_mu_depth_to sdepth E ψ1
  `max` maximal_mu_depth_to sdepth E ψ2
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ1 ∪ free_evars ψ2
wfψ1: well_formed ψ1 = true
H: size' ψ1 ≤ sz
wfψ2: well_formed ψ2 = true
H0: size' ψ2 ≤ sz
Hef1: fresh_evars el
  (free_evars ψ1 ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hsf1: fresh_svars sl
  (free_svars ψ1 ∪ free_svars p ∪ free_svars q)
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]]
using gpi
Hef2: fresh_evars el
  (free_evars ψ2 ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hsf2: fresh_svars sl
  (free_svars ψ2 ∪ free_svars p ∪ free_svars q)
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]]
using gpi
well_formed ψ2^[[evar:E↦p]] = true abstract (wf_auto2). }
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ1, ψ2: Pattern
wfψ: well_formed (ψ1 ---> ψ2)
Hsz: S (size' ψ1 + size' ψ2) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (ψ1 ---> ψ2) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ψ1 ∪ free_evars ψ2 ∪ free_evars p
   ∪ free_evars q ∪ {[E]})
Hel2: length el
≥ maximal_exists_depth_to edepth E ψ1
  `max` maximal_exists_depth_to edepth E ψ2
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars ψ1 ∪ free_svars ψ2 ∪ free_svars p
   ∪ free_svars q)
Hsl2: length sl
≥ maximal_mu_depth_to sdepth E ψ1
  `max` maximal_mu_depth_to sdepth E ψ2
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ1 ∪ free_evars ψ2
wfψ1: well_formed ψ1 = true
H: size' ψ1 ≤ sz
wfψ2: well_formed ψ2 = true
H0: size' ψ2 ≤ sz
Hef1: fresh_evars el
  (free_evars ψ1 ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hsf1: fresh_svars sl
  (free_svars ψ1 ∪ free_svars p ∪ free_svars q)
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]]
using gpi
Hef2: fresh_evars el
  (free_evars ψ2 ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hsf2: fresh_svars sl
  (free_svars ψ2 ∪ free_svars p ∪ free_svars q)
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]]
using gpi
well_formed ψ1^[[evar:E↦q]] = true
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ1, ψ2: Pattern
wfψ: well_formed (ψ1 ---> ψ2)
Hsz: S (size' ψ1 + size' ψ2) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (ψ1 ---> ψ2) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ψ1 ∪ free_evars ψ2 ∪ free_evars p
   ∪ free_evars q ∪ {[E]})
Hel2: length el
≥ maximal_exists_depth_to edepth E ψ1
  `max` maximal_exists_depth_to edepth E ψ2
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars ψ1 ∪ free_svars ψ2 ∪ free_svars p
   ∪ free_svars q)
Hsl2: length sl
≥ maximal_mu_depth_to sdepth E ψ1
  `max` maximal_mu_depth_to sdepth E ψ2
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ1 ∪ free_evars ψ2
wfψ1: well_formed ψ1 = true
H: size' ψ1 ≤ sz
wfψ2: well_formed ψ2 = true
H0: size' ψ2 ≤ sz
Hef1: fresh_evars el
  (free_evars ψ1 ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hsf1: fresh_svars sl
  (free_svars ψ1 ∪ free_svars p ∪ free_svars q)
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]]
using gpi
Hef2: fresh_evars el
  (free_evars ψ2 ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hsf2: fresh_svars sl
  (free_svars ψ2 ∪ free_svars p ∪ free_svars q)
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]]
using gpi
well_formed ψ2^[[evar:E↦q]] = true
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ1, ψ2: Pattern
wfψ: well_formed (ψ1 ---> ψ2)
Hsz: S (size' ψ1 + size' ψ2) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (ψ1 ---> ψ2) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ψ1 ∪ free_evars ψ2 ∪ free_evars p
   ∪ free_evars q ∪ {[E]})
Hel2: length el
≥ maximal_exists_depth_to edepth E ψ1
  `max` maximal_exists_depth_to edepth E ψ2
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars ψ1 ∪ free_svars ψ2 ∪ free_svars p
   ∪ free_svars q)
Hsl2: length sl
≥ maximal_mu_depth_to sdepth E ψ1
  `max` maximal_mu_depth_to sdepth E ψ2
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ1 ∪ free_evars ψ2
wfψ1: well_formed ψ1 = true
H: size' ψ1 ≤ sz
wfψ2: well_formed ψ2 = true
H0: size' ψ2 ≤ sz
Hef1: fresh_evars el
  (free_evars ψ1 ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hsf1: fresh_svars sl
  (free_svars ψ1 ∪ free_svars p ∪ free_svars q)
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]]
using gpi
Hef2: fresh_evars el
  (free_evars ψ2 ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hsf2: fresh_svars sl
  (free_svars ψ2 ∪ free_svars p ∪ free_svars q)
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]]
using gpi
Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]] using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ1, ψ2: Pattern
wfψ: well_formed (ψ1 ---> ψ2)
Hsz: S (size' ψ1 + size' ψ2) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (ψ1 ---> ψ2) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ψ1 ∪ free_evars ψ2 ∪ free_evars p
   ∪ free_evars q ∪ {[E]})
Hel2: length el
≥ maximal_exists_depth_to edepth E ψ1
  `max` maximal_exists_depth_to edepth E ψ2
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars ψ1 ∪ free_svars ψ2 ∪ free_svars p
   ∪ free_svars q)
Hsl2: length sl
≥ maximal_mu_depth_to sdepth E ψ1
  `max` maximal_mu_depth_to sdepth E ψ2
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ1 ∪ free_evars ψ2
wfψ1: well_formed ψ1 = true
H: size' ψ1 ≤ sz
wfψ2: well_formed ψ2 = true
H0: size' ψ2 ≤ sz
Hef1: fresh_evars el
  (free_evars ψ1 ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hsf1: fresh_svars sl
  (free_svars ψ1 ∪ free_svars p ∪ free_svars q)
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]]
using gpi
Hef2: fresh_evars el
  (free_evars ψ2 ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hsf2: fresh_svars sl
  (free_svars ψ2 ∪ free_svars p ∪ free_svars q)
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]]
using gpi
Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]] using gpi
      {
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ1, ψ2: Pattern
wfψ: well_formed (ψ1 ---> ψ2)
Hsz: S (size' ψ1 + size' ψ2) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (ψ1 ---> ψ2) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ψ1 ∪ free_evars ψ2 ∪ free_evars p
   ∪ free_evars q ∪ {[E]})
Hel2: length el
≥ maximal_exists_depth_to edepth E ψ1
  `max` maximal_exists_depth_to edepth E ψ2
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars ψ1 ∪ free_svars ψ2 ∪ free_svars p
   ∪ free_svars q)
Hsl2: length sl
≥ maximal_mu_depth_to sdepth E ψ1
  `max` maximal_mu_depth_to sdepth E ψ2
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ1 ∪ free_evars ψ2
wfψ1: well_formed ψ1 = true
H: size' ψ1 ≤ sz
wfψ2: well_formed ψ2 = true
H0: size' ψ2 ≤ sz
Hef1: fresh_evars el
  (free_evars ψ1 ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hsf1: fresh_svars sl
  (free_svars ψ1 ∪ free_svars p ∪ free_svars q)
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]]
using gpi
Hef2: fresh_evars el
  (free_evars ψ2 ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hsf2: fresh_svars sl
  (free_svars ψ2 ∪ free_svars p ∪ free_svars q)
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]]
using gpi
well_formed ψ1^[[evar:E↦q]] = true abstract (wf_auto2). }
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ1, ψ2: Pattern
wfψ: well_formed (ψ1 ---> ψ2)
Hsz: S (size' ψ1 + size' ψ2) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (ψ1 ---> ψ2) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ψ1 ∪ free_evars ψ2 ∪ free_evars p
   ∪ free_evars q ∪ {[E]})
Hel2: length el
≥ maximal_exists_depth_to edepth E ψ1
  `max` maximal_exists_depth_to edepth E ψ2
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars ψ1 ∪ free_svars ψ2 ∪ free_svars p
   ∪ free_svars q)
Hsl2: length sl
≥ maximal_mu_depth_to sdepth E ψ1
  `max` maximal_mu_depth_to sdepth E ψ2
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ1 ∪ free_evars ψ2
wfψ1: well_formed ψ1 = true
H: size' ψ1 ≤ sz
wfψ2: well_formed ψ2 = true
H0: size' ψ2 ≤ sz
Hef1: fresh_evars el
  (free_evars ψ1 ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hsf1: fresh_svars sl
  (free_svars ψ1 ∪ free_svars p ∪ free_svars q)
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]]
using gpi
Hef2: fresh_evars el
  (free_evars ψ2 ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hsf2: fresh_svars sl
  (free_svars ψ2 ∪ free_svars p ∪ free_svars q)
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]]
using gpi
well_formed ψ2^[[evar:E↦q]] = true
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ1, ψ2: Pattern
wfψ: well_formed (ψ1 ---> ψ2)
Hsz: S (size' ψ1 + size' ψ2) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (ψ1 ---> ψ2) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ψ1 ∪ free_evars ψ2 ∪ free_evars p
   ∪ free_evars q ∪ {[E]})
Hel2: length el
≥ maximal_exists_depth_to edepth E ψ1
  `max` maximal_exists_depth_to edepth E ψ2
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars ψ1 ∪ free_svars ψ2 ∪ free_svars p
   ∪ free_svars q)
Hsl2: length sl
≥ maximal_mu_depth_to sdepth E ψ1
  `max` maximal_mu_depth_to sdepth E ψ2
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ1 ∪ free_evars ψ2
wfψ1: well_formed ψ1 = true
H: size' ψ1 ≤ sz
wfψ2: well_formed ψ2 = true
H0: size' ψ2 ≤ sz
Hef1: fresh_evars el
  (free_evars ψ1 ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hsf1: fresh_svars sl
  (free_svars ψ1 ∪ free_svars p ∪ free_svars q)
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]]
using gpi
Hef2: fresh_evars el
  (free_evars ψ2 ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hsf2: fresh_svars sl
  (free_svars ψ2 ∪ free_svars p ∪ free_svars q)
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]]
using gpi
Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]] using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ1, ψ2: Pattern
wfψ: well_formed (ψ1 ---> ψ2)
Hsz: S (size' ψ1 + size' ψ2) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (ψ1 ---> ψ2) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ψ1 ∪ free_evars ψ2 ∪ free_evars p
   ∪ free_evars q ∪ {[E]})
Hel2: length el
≥ maximal_exists_depth_to edepth E ψ1
  `max` maximal_exists_depth_to edepth E ψ2
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars ψ1 ∪ free_svars ψ2 ∪ free_svars p
   ∪ free_svars q)
Hsl2: length sl
≥ maximal_mu_depth_to sdepth E ψ1
  `max` maximal_mu_depth_to sdepth E ψ2
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ1 ∪ free_evars ψ2
wfψ1: well_formed ψ1 = true
H: size' ψ1 ≤ sz
wfψ2: well_formed ψ2 = true
H0: size' ψ2 ≤ sz
Hef1: fresh_evars el
  (free_evars ψ1 ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hsf1: fresh_svars sl
  (free_svars ψ1 ∪ free_svars p ∪ free_svars q)
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]]
using gpi
Hef2: fresh_evars el
  (free_evars ψ2 ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hsf2: fresh_svars sl
  (free_svars ψ2 ∪ free_svars p ∪ free_svars q)
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]]
using gpi
Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]] using gpi
      {
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ1, ψ2: Pattern
wfψ: well_formed (ψ1 ---> ψ2)
Hsz: S (size' ψ1 + size' ψ2) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (ψ1 ---> ψ2) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ψ1 ∪ free_evars ψ2 ∪ free_evars p
   ∪ free_evars q ∪ {[E]})
Hel2: length el
≥ maximal_exists_depth_to edepth E ψ1
  `max` maximal_exists_depth_to edepth E ψ2
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars ψ1 ∪ free_svars ψ2 ∪ free_svars p
   ∪ free_svars q)
Hsl2: length sl
≥ maximal_mu_depth_to sdepth E ψ1
  `max` maximal_mu_depth_to sdepth E ψ2
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ1 ∪ free_evars ψ2
wfψ1: well_formed ψ1 = true
H: size' ψ1 ≤ sz
wfψ2: well_formed ψ2 = true
H0: size' ψ2 ≤ sz
Hef1: fresh_evars el
  (free_evars ψ1 ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hsf1: fresh_svars sl
  (free_svars ψ1 ∪ free_svars p ∪ free_svars q)
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]]
using gpi
Hef2: fresh_evars el
  (free_evars ψ2 ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hsf2: fresh_svars sl
  (free_svars ψ2 ∪ free_svars p ∪ free_svars q)
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]]
using gpi
well_formed ψ2^[[evar:E↦q]] = true abstract (wf_auto2). }
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ1, ψ2: Pattern
wfψ: well_formed (ψ1 ---> ψ2)
Hsz: S (size' ψ1 + size' ψ2) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (ψ1 ---> ψ2) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ψ1 ∪ free_evars ψ2 ∪ free_evars p
   ∪ free_evars q ∪ {[E]})
Hel2: length el
≥ maximal_exists_depth_to edepth E ψ1
  `max` maximal_exists_depth_to edepth E ψ2
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars ψ1 ∪ free_svars ψ2 ∪ free_svars p
   ∪ free_svars q)
Hsl2: length sl
≥ maximal_mu_depth_to sdepth E ψ1
  `max` maximal_mu_depth_to sdepth E ψ2
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ1 ∪ free_evars ψ2
wfψ1: well_formed ψ1 = true
H: size' ψ1 ≤ sz
wfψ2: well_formed ψ2 = true
H0: size' ψ2 ≤ sz
Hef1: fresh_evars el
  (free_evars ψ1 ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hsf1: fresh_svars sl
  (free_svars ψ1 ∪ free_svars p ∪ free_svars q)
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]]
using gpi
Hef2: fresh_evars el
  (free_evars ψ2 ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hsf2: fresh_svars sl
  (free_svars ψ2 ∪ free_svars p ∪ free_svars q)
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]]
using gpi
Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]] using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ1, ψ2: Pattern
wfψ: well_formed (ψ1 ---> ψ2)
Hsz: S (size' ψ1 + size' ψ2) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (ψ1 ---> ψ2) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ψ1 ∪ free_evars ψ2 ∪ free_evars p
   ∪ free_evars q ∪ {[E]})
Hel2: length el
≥ maximal_exists_depth_to edepth E ψ1
  `max` maximal_exists_depth_to edepth E ψ2
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars ψ1 ∪ free_svars ψ2 ∪ free_svars p
   ∪ free_svars q)
Hsl2: length sl
≥ maximal_mu_depth_to sdepth E ψ1
  `max` maximal_mu_depth_to sdepth E ψ2
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ1 ∪ free_evars ψ2
wfψ1: well_formed ψ1 = true
H: size' ψ1 ≤ sz
wfψ2: well_formed ψ2 = true
H0: size' ψ2 ≤ sz
Hef1: fresh_evars el
  (free_evars ψ1 ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hsf1: fresh_svars sl
  (free_svars ψ1 ∪ free_svars p ∪ free_svars q)
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]]
using gpi
Hef2: fresh_evars el
  (free_evars ψ2 ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hsf2: fresh_svars sl
  (free_svars ψ2 ∪ free_svars p ∪ free_svars q)
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]]
using gpi
Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]] using gpi
      {
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ1, ψ2: Pattern
wfψ: well_formed (ψ1 ---> ψ2)
Hsz: S (size' ψ1 + size' ψ2) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (ψ1 ---> ψ2) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ψ1 ∪ free_evars ψ2 ∪ free_evars p
   ∪ free_evars q ∪ {[E]})
Hel2: length el
≥ maximal_exists_depth_to edepth E ψ1
  `max` maximal_exists_depth_to edepth E ψ2
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars ψ1 ∪ free_svars ψ2 ∪ free_svars p
   ∪ free_svars q)
Hsl2: length sl
≥ maximal_mu_depth_to sdepth E ψ1
  `max` maximal_mu_depth_to sdepth E ψ2
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ1 ∪ free_evars ψ2
wfψ1: well_formed ψ1 = true
H: size' ψ1 ≤ sz
wfψ2: well_formed ψ2 = true
H0: size' ψ2 ≤ sz
Hef1: fresh_evars el
  (free_evars ψ1 ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hsf1: fresh_svars sl
  (free_svars ψ1 ∪ free_svars p ∪ free_svars q)
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]]
using gpi
Hef2: fresh_evars el
  (free_evars ψ2 ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hsf2: fresh_svars sl
  (free_svars ψ2 ∪ free_svars p ∪ free_svars q)
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]]
using gpi
Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]] using gpi apply pf₁. }
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ1, ψ2: Pattern
wfψ: well_formed (ψ1 ---> ψ2)
Hsz: S (size' ψ1 + size' ψ2) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (ψ1 ---> ψ2) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ψ1 ∪ free_evars ψ2 ∪ free_evars p
   ∪ free_evars q ∪ {[E]})
Hel2: length el
≥ maximal_exists_depth_to edepth E ψ1
  `max` maximal_exists_depth_to edepth E ψ2
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars ψ1 ∪ free_svars ψ2 ∪ free_svars p
   ∪ free_svars q)
Hsl2: length sl
≥ maximal_mu_depth_to sdepth E ψ1
  `max` maximal_mu_depth_to sdepth E ψ2
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ1 ∪ free_evars ψ2
wfψ1: well_formed ψ1 = true
H: size' ψ1 ≤ sz
wfψ2: well_formed ψ2 = true
H0: size' ψ2 ≤ sz
Hef1: fresh_evars el
  (free_evars ψ1 ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hsf1: fresh_svars sl
  (free_svars ψ1 ∪ free_svars p ∪ free_svars q)
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]]
using gpi
Hef2: fresh_evars el
  (free_evars ψ2 ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hsf2: fresh_svars sl
  (free_svars ψ2 ∪ free_svars p ∪ free_svars q)
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]]
using gpi
Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]] using gpi
      {
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ1, ψ2: Pattern
wfψ: well_formed (ψ1 ---> ψ2)
Hsz: S (size' ψ1 + size' ψ2) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (ψ1 ---> ψ2) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ψ1 ∪ free_evars ψ2 ∪ free_evars p
   ∪ free_evars q ∪ {[E]})
Hel2: length el
≥ maximal_exists_depth_to edepth E ψ1
  `max` maximal_exists_depth_to edepth E ψ2
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars ψ1 ∪ free_svars ψ2 ∪ free_svars p
   ∪ free_svars q)
Hsl2: length sl
≥ maximal_mu_depth_to sdepth E ψ1
  `max` maximal_mu_depth_to sdepth E ψ2
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ1 ∪ free_evars ψ2
wfψ1: well_formed ψ1 = true
H: size' ψ1 ≤ sz
wfψ2: well_formed ψ2 = true
H0: size' ψ2 ≤ sz
Hef1: fresh_evars el
  (free_evars ψ1 ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hsf1: fresh_svars sl
  (free_svars ψ1 ∪ free_svars p ∪ free_svars q)
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]]
using gpi
Hef2: fresh_evars el
  (free_evars ψ2 ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hsf2: fresh_svars sl
  (free_svars ψ2 ∪ free_svars p ∪ free_svars q)
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]]
using gpi
Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]] using gpi apply pf₂. }
    }
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (ex , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (ex , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars (ex , ψ) ∪ free_evars p
   ∪ free_evars q ∪ {[E]})
Hel2: length el
≥ maximal_exists_depth_to edepth E (ex , ψ)
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars (ex , ψ) ∪ free_svars p
   ∪ free_svars q)
Hsl2: length sl
≥ maximal_mu_depth_to sdepth E (ex , ψ)
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars (ex , ψ)
Γ ⊢i (ex , ψ^[[evar:E↦p]]) <---> (ex , ψ^[[evar:E↦q]])
using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (mu , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars (mu , ψ) ∪ free_evars p
   ∪ free_evars q ∪ {[E]})
Hel2: length el
≥ maximal_exists_depth_to edepth E (mu , ψ)
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars (mu , ψ) ∪ free_svars p
   ∪ free_svars q)
Hsl2: length sl
≥ maximal_mu_depth_to sdepth E (mu , ψ)
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars (mu , ψ)
Γ ⊢i (mu , ψ^[[evar:E↦p]]) <---> (mu , ψ^[[evar:E↦q]])
using gpi
    {
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (ex , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (ex , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars (ex , ψ) ∪ free_evars p
   ∪ free_evars q ∪ {[E]})
Hel2: length el
≥ maximal_exists_depth_to edepth E (ex , ψ)
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars (ex , ψ) ∪ free_svars p
   ∪ free_svars q)
Hsl2: length sl
≥ maximal_mu_depth_to sdepth E (ex , ψ)
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars (ex , ψ)
Γ ⊢i (ex , ψ^[[evar:E↦p]]) <---> (ex , ψ^[[evar:E↦q]])
using gpi
      simpl in *.
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (ex , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (ex , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel2: length el
≥ maximal_exists_depth_to (S edepth) E ψ
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ
Γ ⊢i (ex , ψ^[[evar:E↦p]]) <---> (ex , ψ^[[evar:E↦q]])
using gpi
      
      destruct el as [ | x els].
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (ex , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (ex , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
Hel1: fresh_evars []
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel2: length []
≥ maximal_exists_depth_to (S edepth) E ψ
Hel3: ∀ x : evar, x ∈ [] → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ
Γ ⊢i (ex , ψ^[[evar:E↦p]]) <---> (ex , ψ^[[evar:E↦q]])
using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (ex , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (ex , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
x: evar
els: list evar
Hel1: fresh_evars (x :: els)
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel2: length (x :: els)
≥ maximal_exists_depth_to (S edepth) E ψ
Hel3: ∀ x0 : evar, x0 ∈ x :: els → x0 ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ
Γ ⊢i (ex , ψ^[[evar:E↦p]]) <---> (ex , ψ^[[evar:E↦q]])
using gpi
      {
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (ex , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (ex , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
Hel1: fresh_evars []
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel2: length []
≥ maximal_exists_depth_to (S edepth) E ψ
Hel3: ∀ x : evar, x ∈ [] → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ
Γ ⊢i (ex , ψ^[[evar:E↦p]]) <---> (ex , ψ^[[evar:E↦q]])
using gpi simpl in Hel2.
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (ex , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (ex , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
Hel1: fresh_evars []
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel2: 0 ≥ maximal_exists_depth_to (S edepth) E ψ
Hel3: ∀ x : evar, x ∈ [] → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ
Γ ⊢i (ex , ψ^[[evar:E↦p]]) <---> (ex , ψ^[[evar:E↦q]])
using gpi
        rewrite maximal_exists_depth_to_S in Hel2.
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (ex , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (ex , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
Hel1: fresh_evars []
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel3: ∀ x : evar, x ∈ [] → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ
E ∈ free_evars ψ
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (ex , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (ex , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
Hel1: fresh_evars []
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel3: ∀ x : evar, x ∈ [] → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ
Hel2: 0 ≥ S (maximal_exists_depth_to edepth E ψ)
Γ ⊢i (ex , ψ^[[evar:E↦p]]) <---> (ex , ψ^[[evar:E↦q]])
using gpi assumption.
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (ex , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (ex , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
Hel1: fresh_evars []
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel3: ∀ x : evar, x ∈ [] → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ
Hel2: 0 ≥ S (maximal_exists_depth_to edepth E ψ)
Γ ⊢i (ex , ψ^[[evar:E↦p]]) <---> (ex , ψ^[[evar:E↦q]])
using gpi lia.
      }
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (ex , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (ex , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
x: evar
els: list evar
Hel1: fresh_evars (x :: els)
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel2: length (x :: els)
≥ maximal_exists_depth_to (S edepth) E ψ
Hel3: ∀ x0 : evar, x0 ∈ x :: els → x0 ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ
Γ ⊢i (ex , ψ^[[evar:E↦p]]) <---> (ex , ψ^[[evar:E↦q]])
using gpi
      
      assert (well_formed (ψ^{evar: 0 ↦ x})) by (unfold i' in pile; clear i'; abstract(wf_auto2)).
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (ex , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (ex , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
x: evar
els: list evar
Hel1: fresh_evars (x :: els)
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel2: length (x :: els)
≥ maximal_exists_depth_to (S edepth) E ψ
Hel3: ∀ x0 : evar, x0 ∈ x :: els → x0 ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{evar:0↦x}
Γ ⊢i (ex , ψ^[[evar:E↦p]]) <---> (ex , ψ^[[evar:E↦q]])
using gpi
      assert (size' (ψ^{evar: 0 ↦ x}) <= sz) by abstract(rewrite evar_open_size'; lia).
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (ex , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (ex , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
x: evar
els: list evar
Hel1: fresh_evars (x :: els)
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel2: length (x :: els)
≥ maximal_exists_depth_to (S edepth) E ψ
Hel3: ∀ x0 : evar, x0 ∈ x :: els → x0 ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{evar:0↦x}
H0: size' ψ^{evar:0↦x} ≤ sz
Γ ⊢i (ex , ψ^[[evar:E↦p]]) <---> (ex , ψ^[[evar:E↦q]])
using gpi

      assert (fresh_evars els (free_evars ψ^{evar:0↦x} ∪ free_evars p ∪ free_evars q ∪ {[E]})) as HVars.
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (ex , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (ex , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
x: evar
els: list evar
Hel1: fresh_evars (x :: els)
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel2: length (x :: els)
≥ maximal_exists_depth_to (S edepth) E ψ
Hel3: ∀ x0 : evar, x0 ∈ x :: els → x0 ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{evar:0↦x}
H0: size' ψ^{evar:0↦x} ≤ sz
fresh_evars els
  (free_evars ψ^{evar:0↦x} ∪ free_evars p
   ∪ free_evars q ∪ {[E]})
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (ex , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (ex , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
x: evar
els: list evar
Hel1: fresh_evars (x :: els)
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel2: length (x :: els)
≥ maximal_exists_depth_to (S edepth) E ψ
Hel3: ∀ x0 : evar, x0 ∈ x :: els → x0 ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{evar:0↦x}
H0: size' ψ^{evar:0↦x} ≤ sz
HVars: fresh_evars els
  (free_evars ψ^{evar:0↦x} ∪ free_evars p
   ∪ free_evars q ∪ {[E]})
Γ ⊢i (ex , ψ^[[evar:E↦p]]) <---> (ex , ψ^[[evar:E↦q]])
using gpi {
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (ex , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (ex , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
x: evar
els: list evar
Hel1: fresh_evars (x :: els)
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel2: length (x :: els)
≥ maximal_exists_depth_to (S edepth) E ψ
Hel3: ∀ x0 : evar, x0 ∈ x :: els → x0 ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{evar:0↦x}
H0: size' ψ^{evar:0↦x} ≤ sz
fresh_evars els
  (free_evars ψ^{evar:0↦x} ∪ free_evars p
   ∪ free_evars q ∪ {[E]}) constructor.
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (ex , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (ex , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
x: evar
els: list evar
Hel1: fresh_evars (x :: els)
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel2: length (x :: els)
≥ maximal_exists_depth_to (S edepth) E ψ
Hel3: ∀ x0 : evar, x0 ∈ x :: els → x0 ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{evar:0↦x}
H0: size' ψ^{evar:0↦x} ≤ sz
no_dups els
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (ex , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (ex , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
x: evar
els: list evar
Hel1: fresh_evars (x :: els)
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel2: length (x :: els)
≥ maximal_exists_depth_to (S edepth) E ψ
Hel3: ∀ x0 : evar, x0 ∈ x :: els → x0 ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{evar:0↦x}
H0: size' ψ^{evar:0↦x} ≤ sz
∀ x0 : evar,
  x0 ∈ els
  → x0
    ∉ free_evars ψ^{evar:0↦x} ∪ free_evars p
      ∪ free_evars q ∪ {[E]}
        *
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (ex , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (ex , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
x: evar
els: list evar
Hel1: fresh_evars (x :: els)
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel2: length (x :: els)
≥ maximal_exists_depth_to (S edepth) E ψ
Hel3: ∀ x0 : evar, x0 ∈ x :: els → x0 ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{evar:0↦x}
H0: size' ψ^{evar:0↦x} ≤ sz
no_dups els destruct Hel1.
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (ex , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (ex , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
x: evar
els: list evar
evar_duplicates0: no_dups (x :: els)
all_evars_fresh0: ∀ x0 : evar,
  x0 ∈ x :: els
  → x0
    ∉ free_evars ψ ∪ free_evars p
      ∪ free_evars q ∪ {[E]}
Hel2: length (x :: els)
≥ maximal_exists_depth_to (S edepth) E ψ
Hel3: ∀ x0 : evar, x0 ∈ x :: els → x0 ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{evar:0↦x}
H0: size' ψ^{evar:0↦x} ≤ sz
no_dups els apply evar_duplicates0.
        *
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (ex , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (ex , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
x: evar
els: list evar
Hel1: fresh_evars (x :: els)
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel2: length (x :: els)
≥ maximal_exists_depth_to (S edepth) E ψ
Hel3: ∀ x0 : evar, x0 ∈ x :: els → x0 ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{evar:0↦x}
H0: size' ψ^{evar:0↦x} ≤ sz
∀ x0 : evar,
  x0 ∈ els
  → x0
    ∉ free_evars ψ^{evar:0↦x} ∪ free_evars p
      ∪ free_evars q ∪ {[E]} destruct Hel1.
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (ex , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (ex , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
x: evar
els: list evar
evar_duplicates0: no_dups (x :: els)
all_evars_fresh0: ∀ x0 : evar,
  x0 ∈ x :: els
  → x0
    ∉ free_evars ψ ∪ free_evars p
      ∪ free_evars q ∪ {[E]}
Hel2: length (x :: els)
≥ maximal_exists_depth_to (S edepth) E ψ
Hel3: ∀ x0 : evar, x0 ∈ x :: els → x0 ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{evar:0↦x}
H0: size' ψ^{evar:0↦x} ≤ sz
∀ x0 : evar,
  x0 ∈ els
  → x0
    ∉ free_evars ψ^{evar:0↦x} ∪ free_evars p
      ∪ free_evars q ∪ {[E]} intros.
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (ex , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (ex , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
x: evar
els: list evar
evar_duplicates0: no_dups (x :: els)
all_evars_fresh0: ∀ x0 : evar,
  x0 ∈ x :: els
  → x0
    ∉ free_evars ψ ∪ free_evars p
      ∪ free_evars q ∪ {[E]}
Hel2: length (x :: els)
≥ maximal_exists_depth_to (S edepth) E ψ
Hel3: ∀ x0 : evar, x0 ∈ x :: els → x0 ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{evar:0↦x}
H0: size' ψ^{evar:0↦x} ≤ sz
x0: evar
H1: x0 ∈ els
x0
∉ free_evars ψ^{evar:0↦x} ∪ free_evars p
  ∪ free_evars q ∪ {[E]}
          pose proof (free_evars_evar_open ψ x 0).
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (ex , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (ex , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
x: evar
els: list evar
evar_duplicates0: no_dups (x :: els)
all_evars_fresh0: ∀ x0 : evar,
  x0 ∈ x :: els
  → x0
    ∉ free_evars ψ ∪ free_evars p
      ∪ free_evars q ∪ {[E]}
Hel2: length (x :: els)
≥ maximal_exists_depth_to (S edepth) E ψ
Hel3: ∀ x0 : evar, x0 ∈ x :: els → x0 ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{evar:0↦x}
H0: size' ψ^{evar:0↦x} ≤ sz
x0: evar
H1: x0 ∈ els
H2: free_evars ψ^{evar:0↦x} ⊆ {[x]} ∪ free_evars ψ
x0
∉ free_evars ψ^{evar:0↦x} ∪ free_evars p
  ∪ free_evars q ∪ {[E]}
          specialize (all_evars_fresh0 x0 ltac:(now right)).
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (ex , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (ex , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
x: evar
els: list evar
evar_duplicates0: no_dups (x :: els)
x0: evar
all_evars_fresh0: x0
∉ free_evars ψ ∪ free_evars p
  ∪ free_evars q ∪ {[E]}
Hel2: length (x :: els)
≥ maximal_exists_depth_to (S edepth) E ψ
Hel3: ∀ x0 : evar, x0 ∈ x :: els → x0 ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{evar:0↦x}
H0: size' ψ^{evar:0↦x} ≤ sz
H1: x0 ∈ els
H2: free_evars ψ^{evar:0↦x} ⊆ {[x]} ∪ free_evars ψ
x0
∉ free_evars ψ^{evar:0↦x} ∪ free_evars p
  ∪ free_evars q ∪ {[E]}
          simpl in *.
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (ex , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (ex , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
x: evar
els: list evar
evar_duplicates0: (x ∉ els) ∧ no_dups els
x0: evar
all_evars_fresh0: x0
∉ free_evars ψ ∪ free_evars p
  ∪ free_evars q ∪ {[E]}
Hel2: S (length els)
≥ maximal_exists_depth_to (S edepth) E ψ
Hel3: ∀ x0 : evar, x0 ∈ x :: els → x0 ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{evar:0↦x}
H0: size' ψ^{evar:0↦x} ≤ sz
H1: x0 ∈ els
H2: free_evars ψ^{evar:0↦x} ⊆ {[x]} ∪ free_evars ψ
x0
∉ free_evars ψ^{evar:0↦x} ∪ free_evars p
  ∪ free_evars q ∪ {[E]} destruct evar_duplicates0.
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (ex , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (ex , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
x: evar
els: list evar
H3: x ∉ els
H4: no_dups els
x0: evar
all_evars_fresh0: x0
∉ free_evars ψ ∪ free_evars p
  ∪ free_evars q ∪ {[E]}
Hel2: S (length els)
≥ maximal_exists_depth_to (S edepth) E ψ
Hel3: ∀ x0 : evar, x0 ∈ x :: els → x0 ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{evar:0↦x}
H0: size' ψ^{evar:0↦x} ≤ sz
H1: x0 ∈ els
H2: free_evars ψ^{evar:0↦x} ⊆ {[x]} ∪ free_evars ψ
x0
∉ free_evars ψ^{evar:0↦x} ∪ free_evars p
  ∪ free_evars q ∪ {[E]} set_solver.
      }
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (ex , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (ex , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
x: evar
els: list evar
Hel1: fresh_evars (x :: els)
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel2: length (x :: els)
≥ maximal_exists_depth_to (S edepth) E ψ
Hel3: ∀ x0 : evar, x0 ∈ x :: els → x0 ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{evar:0↦x}
H0: size' ψ^{evar:0↦x} ≤ sz
HVars: fresh_evars els
  (free_evars ψ^{evar:0↦x} ∪ free_evars p
   ∪ free_evars q ∪ {[E]})
Γ ⊢i (ex , ψ^[[evar:E↦p]]) <---> (ex , ψ^[[evar:E↦q]])
using gpi
      simpl in Hel2.
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (ex , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (ex , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
x: evar
els: list evar
Hel1: fresh_evars (x :: els)
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel2: S (length els)
≥ maximal_exists_depth_to (S edepth) E ψ
Hel3: ∀ x0 : evar, x0 ∈ x :: els → x0 ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{evar:0↦x}
H0: size' ψ^{evar:0↦x} ≤ sz
HVars: fresh_evars els
  (free_evars ψ^{evar:0↦x} ∪ free_evars p
   ∪ free_evars q ∪ {[E]})
Γ ⊢i (ex , ψ^[[evar:E↦p]]) <---> (ex , ψ^[[evar:E↦q]])
using gpi
      rewrite maximal_exists_depth_to_S in Hel2.
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (ex , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (ex , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
x: evar
els: list evar
Hel1: fresh_evars (x :: els)
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel3: ∀ x0 : evar, x0 ∈ x :: els → x0 ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{evar:0↦x}
H0: size' ψ^{evar:0↦x} ≤ sz
HVars: fresh_evars els
  (free_evars ψ^{evar:0↦x} ∪ free_evars p
   ∪ free_evars q ∪ {[E]})
E ∈ free_evars ψ
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (ex , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (ex , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
x: evar
els: list evar
Hel1: fresh_evars (x :: els)
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel3: ∀ x0 : evar, x0 ∈ x :: els → x0 ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{evar:0↦x}
H0: size' ψ^{evar:0↦x} ≤ sz
HVars: fresh_evars els
  (free_evars ψ^{evar:0↦x} ∪ free_evars p
   ∪ free_evars q ∪ {[E]})
Hel2: S (length els)
≥ S (maximal_exists_depth_to edepth E ψ)
Γ ⊢i (ex , ψ^[[evar:E↦p]]) <---> (ex , ψ^[[evar:E↦q]])
using gpi assumption.
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (ex , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (ex , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
x: evar
els: list evar
Hel1: fresh_evars (x :: els)
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel3: ∀ x0 : evar, x0 ∈ x :: els → x0 ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{evar:0↦x}
H0: size' ψ^{evar:0↦x} ≤ sz
HVars: fresh_evars els
  (free_evars ψ^{evar:0↦x} ∪ free_evars p
   ∪ free_evars q ∪ {[E]})
Hel2: S (length els)
≥ S (maximal_exists_depth_to edepth E ψ)
Γ ⊢i (ex , ψ^[[evar:E↦p]]) <---> (ex , ψ^[[evar:E↦q]])
using gpi

      assert (E ≠ x) as HXe.
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (ex , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (ex , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
x: evar
els: list evar
Hel1: fresh_evars (x :: els)
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel3: ∀ x0 : evar, x0 ∈ x :: els → x0 ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{evar:0↦x}
H0: size' ψ^{evar:0↦x} ≤ sz
HVars: fresh_evars els
  (free_evars ψ^{evar:0↦x} ∪ free_evars p
   ∪ free_evars q ∪ {[E]})
Hel2: S (length els)
≥ S (maximal_exists_depth_to edepth E ψ)
E ≠ x
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (ex , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (ex , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
x: evar
els: list evar
Hel1: fresh_evars (x :: els)
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel3: ∀ x0 : evar, x0 ∈ x :: els → x0 ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{evar:0↦x}
H0: size' ψ^{evar:0↦x} ≤ sz
HVars: fresh_evars els
  (free_evars ψ^{evar:0↦x} ∪ free_evars p
   ∪ free_evars q ∪ {[E]})
Hel2: S (length els)
≥ S (maximal_exists_depth_to edepth E ψ)
HXe: E ≠ x
Γ ⊢i (ex , ψ^[[evar:E↦p]]) <---> (ex , ψ^[[evar:E↦q]])
using gpi {
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (ex , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (ex , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
x: evar
els: list evar
Hel1: fresh_evars (x :: els)
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel3: ∀ x0 : evar, x0 ∈ x :: els → x0 ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{evar:0↦x}
H0: size' ψ^{evar:0↦x} ≤ sz
HVars: fresh_evars els
  (free_evars ψ^{evar:0↦x} ∪ free_evars p
   ∪ free_evars q ∪ {[E]})
Hel2: S (length els)
≥ S (maximal_exists_depth_to edepth E ψ)
E ≠ x
        destruct Hel1 as [_ ?].
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (ex , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (ex , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
x: evar
els: list evar
all_evars_fresh0: ∀ x0 : evar,
  x0 ∈ x :: els
  → x0
    ∉ free_evars ψ ∪ free_evars p
      ∪ free_evars q ∪ {[E]}
Hel3: ∀ x0 : evar, x0 ∈ x :: els → x0 ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{evar:0↦x}
H0: size' ψ^{evar:0↦x} ≤ sz
HVars: fresh_evars els
  (free_evars ψ^{evar:0↦x} ∪ free_evars p
   ∪ free_evars q ∪ {[E]})
Hel2: S (length els)
≥ S (maximal_exists_depth_to edepth E ψ)
E ≠ x clear -all_evars_fresh0.
Σ: Signature
p, q: Pattern
E: evar
ψ: Pattern
x: evar
els: list evar
all_evars_fresh0: ∀ x0 : evar,
  x0 ∈ x :: els
  → x0
    ∉ free_evars ψ ∪ free_evars p
      ∪ free_evars q ∪ {[E]}
E ≠ x set_solver.
      }
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (ex , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (ex , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
x: evar
els: list evar
Hel1: fresh_evars (x :: els)
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel3: ∀ x0 : evar, x0 ∈ x :: els → x0 ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{evar:0↦x}
H0: size' ψ^{evar:0↦x} ≤ sz
HVars: fresh_evars els
  (free_evars ψ^{evar:0↦x} ∪ free_evars p
   ∪ free_evars q ∪ {[E]})
Hel2: S (length els)
≥ S (maximal_exists_depth_to edepth E ψ)
HXe: E ≠ x
Γ ⊢i (ex , ψ^[[evar:E↦p]]) <---> (ex , ψ^[[evar:E↦q]])
using gpi
      unshelve (epose proof (IH := IHsz edepth sdepth (ψ^{evar: 0 ↦ x}) ltac:(assumption) ltac:(assumption) (evs ∪ {[x]}) svs gpi _ pf els HVars _ ltac:(set_solver) sl)).
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (ex , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (ex , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
x: evar
els: list evar
Hel1: fresh_evars (x :: els)
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel3: ∀ x0 : evar, x0 ∈ x :: els → x0 ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{evar:0↦x}
H0: size' ψ^{evar:0↦x} ≤ sz
HVars: fresh_evars els
  (free_evars ψ^{evar:0↦x} ∪ free_evars p
   ∪ free_evars q ∪ {[E]})
Hel2: S (length els)
≥ S (maximal_exists_depth_to edepth E ψ)
HXe: E ≠ x
ProofInfoLe
  (ExGen := evs ∪ {[x]}, SVSubst := svs,
   KT := mu_in_evar_path E ψ^{evar:0↦x} sdepth) gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (ex , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (ex , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
x: evar
els: list evar
Hel1: fresh_evars (x :: els)
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel3: ∀ x0 : evar, x0 ∈ x :: els → x0 ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{evar:0↦x}
H0: size' ψ^{evar:0↦x} ≤ sz
HVars: fresh_evars els
  (free_evars ψ^{evar:0↦x} ∪ free_evars p
   ∪ free_evars q ∪ {[E]})
Hel2: S (length els)
≥ S (maximal_exists_depth_to edepth E ψ)
HXe: E ≠ x
length els
≥ maximal_exists_depth_to edepth E ψ^{evar:0↦x}
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (ex , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (ex , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
x: evar
els: list evar
Hel1: fresh_evars (x :: els)
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel3: ∀ x0 : evar, x0 ∈ x :: els → x0 ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{evar:0↦x}
H0: size' ψ^{evar:0↦x} ≤ sz
HVars: fresh_evars els
  (free_evars ψ^{evar:0↦x} ∪ free_evars p
   ∪ free_evars q ∪ {[E]})
Hel2: S (length els)
≥ S (maximal_exists_depth_to edepth E ψ)
HXe: E ≠ x
IH: fresh_svars sl
  (free_svars ψ^{evar:0↦x} ∪ free_svars p
   ∪ free_svars q)
→ length sl
  ≥ maximal_mu_depth_to sdepth E ψ^{evar:0↦x}
  → (∀ X : svar, X ∈ sl → X ∈ svs)
    → Γ
      ⊢i ψ^{evar:0↦x}^[[evar:E↦p]] <--->
         ψ^{evar:0↦x}^[[evar:E↦q]] using gpi
Γ ⊢i (ex , ψ^[[evar:E↦p]]) <---> (ex , ψ^[[evar:E↦q]])
using gpi
      {
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (ex , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (ex , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
x: evar
els: list evar
Hel1: fresh_evars (x :: els)
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel3: ∀ x0 : evar, x0 ∈ x :: els → x0 ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{evar:0↦x}
H0: size' ψ^{evar:0↦x} ≤ sz
HVars: fresh_evars els
  (free_evars ψ^{evar:0↦x} ∪ free_evars p
   ∪ free_evars q ∪ {[E]})
Hel2: S (length els)
≥ S (maximal_exists_depth_to edepth E ψ)
HXe: E ≠ x
ProofInfoLe
  (ExGen := evs ∪ {[x]}, SVSubst := svs,
   KT := mu_in_evar_path E ψ^{evar:0↦x} sdepth) gpi
        cbn in *.
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (ex , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (ex , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
x: evar
els: list evar
Hel1: fresh_evars (x :: els)
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel3: ∀ x0 : evar, x0 ∈ x :: els → x0 ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{evar:0↦x}
H0: size' ψ^{evar:0↦x} ≤ sz
HVars: fresh_evars els
  (free_evars ψ^{evar:0↦x} ∪ free_evars p
   ∪ free_evars q ∪ {[E]})
Hel2: S (length els)
≥ S (maximal_exists_depth_to edepth E ψ)
HXe: E ≠ x
ProofInfoLe
  (ExGen := evs ∪ {[x]}, SVSubst := svs,
   KT := mu_in_evar_path E ψ^{evar:0↦x} sdepth) gpi unfold mu_in_evar_path in *.
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := ~~
                 (0 =?
                  maximal_mu_depth_to sdepth E
                    ψ)%nat) gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (ex , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := ~~
      (0 =? maximal_mu_depth_to sdepth E (ex , ψ))%nat: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
x: evar
els: list evar
Hel1: fresh_evars (x :: els)
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel3: ∀ x0 : evar, x0 ∈ x :: els → x0 ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{evar:0↦x}
H0: size' ψ^{evar:0↦x} ≤ sz
HVars: fresh_evars els
  (free_evars ψ^{evar:0↦x} ∪ free_evars p
   ∪ free_evars q ∪ {[E]})
Hel2: S (length els)
≥ S (maximal_exists_depth_to edepth E ψ)
HXe: E ≠ x
ProofInfoLe
  (ExGen := evs ∪ {[x]}, SVSubst := svs,
   KT := ~~
         (0 =?
          maximal_mu_depth_to sdepth E ψ^{evar:0↦x})%nat)
  gpi cbn in *.
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := ~~
                 match
                   maximal_mu_depth_to sdepth E
                     ψ
                 with
                 | 0 => true
                 | S _ => false
                 end) gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (ex , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := ~~
      match maximal_mu_depth_to sdepth E ψ with
      | 0 => true
      | S _ => false
      end: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
x: evar
els: list evar
Hel1: fresh_evars (x :: els)
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel3: ∀ x0 : evar, x0 ∈ x :: els → x0 ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{evar:0↦x}
H0: size' ψ^{evar:0↦x} ≤ sz
HVars: fresh_evars els
  (free_evars ψ^{evar:0↦x} ∪ free_evars p
   ∪ free_evars q ∪ {[E]})
Hel2: S (length els)
≥ S (maximal_exists_depth_to edepth E ψ)
HXe: E ≠ x
ProofInfoLe
  (ExGen := evs ∪ {[x]}, SVSubst := svs,
   KT := ~~
         match
           maximal_mu_depth_to sdepth E ψ^{evar:0↦x}
         with
         | 0 => true
         | S _ => false
         end) gpi
        rewrite evar_open_mu_depth.
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := ~~
                 match
                   maximal_mu_depth_to sdepth E
                     ψ
                 with
                 | 0 => true
                 | S _ => false
                 end) gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (ex , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := ~~
      match maximal_mu_depth_to sdepth E ψ with
      | 0 => true
      | S _ => false
      end: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
x: evar
els: list evar
Hel1: fresh_evars (x :: els)
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel3: ∀ x0 : evar, x0 ∈ x :: els → x0 ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{evar:0↦x}
H0: size' ψ^{evar:0↦x} ≤ sz
HVars: fresh_evars els
  (free_evars ψ^{evar:0↦x} ∪ free_evars p
   ∪ free_evars q ∪ {[E]})
Hel2: S (length els)
≥ S (maximal_exists_depth_to edepth E ψ)
HXe: E ≠ x
E ≠ x
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := ~~
                 match
                   maximal_mu_depth_to sdepth E
                     ψ
                 with
                 | 0 => true
                 | S _ => false
                 end) gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (ex , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := ~~
      match maximal_mu_depth_to sdepth E ψ with
      | 0 => true
      | S _ => false
      end: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
x: evar
els: list evar
Hel1: fresh_evars (x :: els)
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel3: ∀ x0 : evar, x0 ∈ x :: els → x0 ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{evar:0↦x}
H0: size' ψ^{evar:0↦x} ≤ sz
HVars: fresh_evars els
  (free_evars ψ^{evar:0↦x} ∪ free_evars p
   ∪ free_evars q ∪ {[E]})
Hel2: S (length els)
≥ S (maximal_exists_depth_to edepth E ψ)
HXe: E ≠ x
ProofInfoLe
  (ExGen := evs ∪ {[x]}, SVSubst := svs,
   KT := ~~
         match maximal_mu_depth_to sdepth E ψ with
         | 0 => true
         | S _ => false
         end) gpi
        2: try_solve_pile.
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := ~~
                 match
                   maximal_mu_depth_to sdepth E
                     ψ
                 with
                 | 0 => true
                 | S _ => false
                 end) gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (ex , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := ~~
      match maximal_mu_depth_to sdepth E ψ with
      | 0 => true
      | S _ => false
      end: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
x: evar
els: list evar
Hel1: fresh_evars (x :: els)
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel3: ∀ x0 : evar, x0 ∈ x :: els → x0 ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{evar:0↦x}
H0: size' ψ^{evar:0↦x} ≤ sz
HVars: fresh_evars els
  (free_evars ψ^{evar:0↦x} ∪ free_evars p
   ∪ free_evars q ∪ {[E]})
Hel2: S (length els)
≥ S (maximal_exists_depth_to edepth E ψ)
HXe: E ≠ x
E ≠ x
        auto.
      }
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (ex , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (ex , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
x: evar
els: list evar
Hel1: fresh_evars (x :: els)
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel3: ∀ x0 : evar, x0 ∈ x :: els → x0 ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{evar:0↦x}
H0: size' ψ^{evar:0↦x} ≤ sz
HVars: fresh_evars els
  (free_evars ψ^{evar:0↦x} ∪ free_evars p
   ∪ free_evars q ∪ {[E]})
Hel2: S (length els)
≥ S (maximal_exists_depth_to edepth E ψ)
HXe: E ≠ x
length els
≥ maximal_exists_depth_to edepth E ψ^{evar:0↦x}
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (ex , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (ex , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
x: evar
els: list evar
Hel1: fresh_evars (x :: els)
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel3: ∀ x0 : evar, x0 ∈ x :: els → x0 ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{evar:0↦x}
H0: size' ψ^{evar:0↦x} ≤ sz
HVars: fresh_evars els
  (free_evars ψ^{evar:0↦x} ∪ free_evars p
   ∪ free_evars q ∪ {[E]})
Hel2: S (length els)
≥ S (maximal_exists_depth_to edepth E ψ)
HXe: E ≠ x
IH: fresh_svars sl
  (free_svars ψ^{evar:0↦x} ∪ free_svars p
   ∪ free_svars q)
→ length sl
  ≥ maximal_mu_depth_to sdepth E ψ^{evar:0↦x}
  → (∀ X : svar, X ∈ sl → X ∈ svs)
    → Γ
      ⊢i ψ^{evar:0↦x}^[[evar:E↦p]] <--->
         ψ^{evar:0↦x}^[[evar:E↦q]] using gpi
Γ ⊢i (ex , ψ^[[evar:E↦p]]) <---> (ex , ψ^[[evar:E↦q]])
using gpi
      {
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (ex , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (ex , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
x: evar
els: list evar
Hel1: fresh_evars (x :: els)
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel3: ∀ x0 : evar, x0 ∈ x :: els → x0 ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{evar:0↦x}
H0: size' ψ^{evar:0↦x} ≤ sz
HVars: fresh_evars els
  (free_evars ψ^{evar:0↦x} ∪ free_evars p
   ∪ free_evars q ∪ {[E]})
Hel2: S (length els)
≥ S (maximal_exists_depth_to edepth E ψ)
HXe: E ≠ x
length els
≥ maximal_exists_depth_to edepth E ψ^{evar:0↦x} rewrite evar_open_exists_depth.
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (ex , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (ex , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
x: evar
els: list evar
Hel1: fresh_evars (x :: els)
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel3: ∀ x0 : evar, x0 ∈ x :: els → x0 ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{evar:0↦x}
H0: size' ψ^{evar:0↦x} ≤ sz
HVars: fresh_evars els
  (free_evars ψ^{evar:0↦x} ∪ free_evars p
   ∪ free_evars q ∪ {[E]})
Hel2: S (length els)
≥ S (maximal_exists_depth_to edepth E ψ)
HXe: E ≠ x
E ≠ x
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (ex , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (ex , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
x: evar
els: list evar
Hel1: fresh_evars (x :: els)
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel3: ∀ x0 : evar, x0 ∈ x :: els → x0 ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{evar:0↦x}
H0: size' ψ^{evar:0↦x} ≤ sz
HVars: fresh_evars els
  (free_evars ψ^{evar:0↦x} ∪ free_evars p
   ∪ free_evars q ∪ {[E]})
Hel2: S (length els)
≥ S (maximal_exists_depth_to edepth E ψ)
HXe: E ≠ x
length els ≥ maximal_exists_depth_to edepth E ψ auto.
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (ex , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (ex , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
x: evar
els: list evar
Hel1: fresh_evars (x :: els)
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel3: ∀ x0 : evar, x0 ∈ x :: els → x0 ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{evar:0↦x}
H0: size' ψ^{evar:0↦x} ≤ sz
HVars: fresh_evars els
  (free_evars ψ^{evar:0↦x} ∪ free_evars p
   ∪ free_evars q ∪ {[E]})
Hel2: S (length els)
≥ S (maximal_exists_depth_to edepth E ψ)
HXe: E ≠ x
length els ≥ maximal_exists_depth_to edepth E ψ lia. }
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (ex , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (ex , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
x: evar
els: list evar
Hel1: fresh_evars (x :: els)
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel3: ∀ x0 : evar, x0 ∈ x :: els → x0 ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{evar:0↦x}
H0: size' ψ^{evar:0↦x} ≤ sz
HVars: fresh_evars els
  (free_evars ψ^{evar:0↦x} ∪ free_evars p
   ∪ free_evars q ∪ {[E]})
Hel2: S (length els)
≥ S (maximal_exists_depth_to edepth E ψ)
HXe: E ≠ x
IH: fresh_svars sl
  (free_svars ψ^{evar:0↦x} ∪ free_svars p
   ∪ free_svars q)
→ length sl
  ≥ maximal_mu_depth_to sdepth E ψ^{evar:0↦x}
  → (∀ X : svar, X ∈ sl → X ∈ svs)
    → Γ
      ⊢i ψ^{evar:0↦x}^[[evar:E↦p]] <--->
         ψ^{evar:0↦x}^[[evar:E↦q]] using gpi
Γ ⊢i (ex , ψ^[[evar:E↦p]]) <---> (ex , ψ^[[evar:E↦q]])
using gpi
      feed specialize IH.
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (ex , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (ex , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
x: evar
els: list evar
Hel1: fresh_evars (x :: els)
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel3: ∀ x0 : evar, x0 ∈ x :: els → x0 ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{evar:0↦x}
H0: size' ψ^{evar:0↦x} ≤ sz
HVars: fresh_evars els
  (free_evars ψ^{evar:0↦x} ∪ free_evars p
   ∪ free_evars q ∪ {[E]})
Hel2: S (length els)
≥ S (maximal_exists_depth_to edepth E ψ)
HXe: E ≠ x
IH: fresh_svars sl
  (free_svars ψ^{evar:0↦x} ∪ free_svars p
   ∪ free_svars q)
→ length sl
  ≥ maximal_mu_depth_to sdepth E ψ^{evar:0↦x}
  → (∀ X : svar, X ∈ sl → X ∈ svs)
    → Γ
      ⊢i ψ^{evar:0↦x}^[[evar:E↦p]] <--->
         ψ^{evar:0↦x}^[[evar:E↦q]] using gpi
fresh_svars sl
  (free_svars ψ^{evar:0↦x} ∪ free_svars p
   ∪ free_svars q)
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (ex , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (ex , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
x: evar
els: list evar
Hel1: fresh_evars (x :: els)
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel3: ∀ x0 : evar, x0 ∈ x :: els → x0 ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{evar:0↦x}
H0: size' ψ^{evar:0↦x} ≤ sz
HVars: fresh_evars els
  (free_evars ψ^{evar:0↦x} ∪ free_evars p
   ∪ free_evars q ∪ {[E]})
Hel2: S (length els)
≥ S (maximal_exists_depth_to edepth E ψ)
HXe: E ≠ x
IH: fresh_svars sl
  (free_svars ψ^{evar:0↦x} ∪ free_svars p
   ∪ free_svars q)
→ length sl
  ≥ maximal_mu_depth_to sdepth E ψ^{evar:0↦x}
  → (∀ X : svar, X ∈ sl → X ∈ svs)
    → Γ
      ⊢i ψ^{evar:0↦x}^[[evar:E↦p]] <--->
         ψ^{evar:0↦x}^[[evar:E↦q]] using gpi
length sl ≥ maximal_mu_depth_to sdepth E ψ^{evar:0↦x}
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (ex , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (ex , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
x: evar
els: list evar
Hel1: fresh_evars (x :: els)
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel3: ∀ x0 : evar, x0 ∈ x :: els → x0 ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{evar:0↦x}
H0: size' ψ^{evar:0↦x} ≤ sz
HVars: fresh_evars els
  (free_evars ψ^{evar:0↦x} ∪ free_evars p
   ∪ free_evars q ∪ {[E]})
Hel2: S (length els)
≥ S (maximal_exists_depth_to edepth E ψ)
HXe: E ≠ x
IH: fresh_svars sl
  (free_svars ψ^{evar:0↦x} ∪ free_svars p
   ∪ free_svars q)
→ length sl
  ≥ maximal_mu_depth_to sdepth E ψ^{evar:0↦x}
  → (∀ X : svar, X ∈ sl → X ∈ svs)
    → Γ
      ⊢i ψ^{evar:0↦x}^[[evar:E↦p]] <--->
         ψ^{evar:0↦x}^[[evar:E↦q]] using gpi
∀ X : svar, X ∈ sl → X ∈ svs
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (ex , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (ex , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
x: evar
els: list evar
Hel1: fresh_evars (x :: els)
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel3: ∀ x0 : evar, x0 ∈ x :: els → x0 ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{evar:0↦x}
H0: size' ψ^{evar:0↦x} ≤ sz
HVars: fresh_evars els
  (free_evars ψ^{evar:0↦x} ∪ free_evars p
   ∪ free_evars q ∪ {[E]})
Hel2: S (length els)
≥ S (maximal_exists_depth_to edepth E ψ)
HXe: E ≠ x
IH: Γ
⊢i ψ^{evar:0↦x}^[[evar:E↦p]] <--->
   ψ^{evar:0↦x}^[[evar:E↦q]] using gpi
Γ ⊢i (ex , ψ^[[evar:E↦p]]) <---> (ex , ψ^[[evar:E↦q]])
using gpi
      {
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (ex , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (ex , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
x: evar
els: list evar
Hel1: fresh_evars (x :: els)
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel3: ∀ x0 : evar, x0 ∈ x :: els → x0 ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{evar:0↦x}
H0: size' ψ^{evar:0↦x} ≤ sz
HVars: fresh_evars els
  (free_evars ψ^{evar:0↦x} ∪ free_evars p
   ∪ free_evars q ∪ {[E]})
Hel2: S (length els)
≥ S (maximal_exists_depth_to edepth E ψ)
HXe: E ≠ x
IH: fresh_svars sl
  (free_svars ψ^{evar:0↦x} ∪ free_svars p
   ∪ free_svars q)
→ length sl
  ≥ maximal_mu_depth_to sdepth E ψ^{evar:0↦x}
  → (∀ X : svar, X ∈ sl → X ∈ svs)
    → Γ
      ⊢i ψ^{evar:0↦x}^[[evar:E↦p]] <--->
         ψ^{evar:0↦x}^[[evar:E↦q]] using gpi
fresh_svars sl
  (free_svars ψ^{evar:0↦x} ∪ free_svars p
   ∪ free_svars q) now rewrite free_svars_evar_open. }
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (ex , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (ex , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
x: evar
els: list evar
Hel1: fresh_evars (x :: els)
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel3: ∀ x0 : evar, x0 ∈ x :: els → x0 ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{evar:0↦x}
H0: size' ψ^{evar:0↦x} ≤ sz
HVars: fresh_evars els
  (free_evars ψ^{evar:0↦x} ∪ free_evars p
   ∪ free_evars q ∪ {[E]})
Hel2: S (length els)
≥ S (maximal_exists_depth_to edepth E ψ)
HXe: E ≠ x
IH: fresh_svars sl
  (free_svars ψ^{evar:0↦x} ∪ free_svars p
   ∪ free_svars q)
→ length sl
  ≥ maximal_mu_depth_to sdepth E ψ^{evar:0↦x}
  → (∀ X : svar, X ∈ sl → X ∈ svs)
    → Γ
      ⊢i ψ^{evar:0↦x}^[[evar:E↦p]] <--->
         ψ^{evar:0↦x}^[[evar:E↦q]] using gpi
length sl ≥ maximal_mu_depth_to sdepth E ψ^{evar:0↦x}
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (ex , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (ex , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
x: evar
els: list evar
Hel1: fresh_evars (x :: els)
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel3: ∀ x0 : evar, x0 ∈ x :: els → x0 ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{evar:0↦x}
H0: size' ψ^{evar:0↦x} ≤ sz
HVars: fresh_evars els
  (free_evars ψ^{evar:0↦x} ∪ free_evars p
   ∪ free_evars q ∪ {[E]})
Hel2: S (length els)
≥ S (maximal_exists_depth_to edepth E ψ)
HXe: E ≠ x
IH: fresh_svars sl
  (free_svars ψ^{evar:0↦x} ∪ free_svars p
   ∪ free_svars q)
→ length sl
  ≥ maximal_mu_depth_to sdepth E ψ^{evar:0↦x}
  → (∀ X : svar, X ∈ sl → X ∈ svs)
    → Γ
      ⊢i ψ^{evar:0↦x}^[[evar:E↦p]] <--->
         ψ^{evar:0↦x}^[[evar:E↦q]] using gpi
∀ X : svar, X ∈ sl → X ∈ svs
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (ex , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (ex , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
x: evar
els: list evar
Hel1: fresh_evars (x :: els)
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel3: ∀ x0 : evar, x0 ∈ x :: els → x0 ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{evar:0↦x}
H0: size' ψ^{evar:0↦x} ≤ sz
HVars: fresh_evars els
  (free_evars ψ^{evar:0↦x} ∪ free_evars p
   ∪ free_evars q ∪ {[E]})
Hel2: S (length els)
≥ S (maximal_exists_depth_to edepth E ψ)
HXe: E ≠ x
IH: Γ
⊢i ψ^{evar:0↦x}^[[evar:E↦p]] <--->
   ψ^{evar:0↦x}^[[evar:E↦q]] using gpi
Γ ⊢i (ex , ψ^[[evar:E↦p]]) <---> (ex , ψ^[[evar:E↦q]])
using gpi
      {
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (ex , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (ex , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
x: evar
els: list evar
Hel1: fresh_evars (x :: els)
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel3: ∀ x0 : evar, x0 ∈ x :: els → x0 ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{evar:0↦x}
H0: size' ψ^{evar:0↦x} ≤ sz
HVars: fresh_evars els
  (free_evars ψ^{evar:0↦x} ∪ free_evars p
   ∪ free_evars q ∪ {[E]})
Hel2: S (length els)
≥ S (maximal_exists_depth_to edepth E ψ)
HXe: E ≠ x
IH: fresh_svars sl
  (free_svars ψ^{evar:0↦x} ∪ free_svars p
   ∪ free_svars q)
→ length sl
  ≥ maximal_mu_depth_to sdepth E ψ^{evar:0↦x}
  → (∀ X : svar, X ∈ sl → X ∈ svs)
    → Γ
      ⊢i ψ^{evar:0↦x}^[[evar:E↦p]] <--->
         ψ^{evar:0↦x}^[[evar:E↦q]] using gpi
length sl ≥ maximal_mu_depth_to sdepth E ψ^{evar:0↦x} rewrite evar_open_mu_depth.
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (ex , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (ex , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
x: evar
els: list evar
Hel1: fresh_evars (x :: els)
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel3: ∀ x0 : evar, x0 ∈ x :: els → x0 ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{evar:0↦x}
H0: size' ψ^{evar:0↦x} ≤ sz
HVars: fresh_evars els
  (free_evars ψ^{evar:0↦x} ∪ free_evars p
   ∪ free_evars q ∪ {[E]})
Hel2: S (length els)
≥ S (maximal_exists_depth_to edepth E ψ)
HXe: E ≠ x
IH: fresh_svars sl
  (free_svars ψ^{evar:0↦x} ∪ free_svars p
   ∪ free_svars q)
→ length sl
  ≥ maximal_mu_depth_to sdepth E ψ^{evar:0↦x}
  → (∀ X : svar, X ∈ sl → X ∈ svs)
    → Γ
      ⊢i ψ^{evar:0↦x}^[[evar:E↦p]] <--->
         ψ^{evar:0↦x}^[[evar:E↦q]] using gpi
E ≠ x
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (ex , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (ex , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
x: evar
els: list evar
Hel1: fresh_evars (x :: els)
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel3: ∀ x0 : evar, x0 ∈ x :: els → x0 ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{evar:0↦x}
H0: size' ψ^{evar:0↦x} ≤ sz
HVars: fresh_evars els
  (free_evars ψ^{evar:0↦x} ∪ free_evars p
   ∪ free_evars q ∪ {[E]})
Hel2: S (length els)
≥ S (maximal_exists_depth_to edepth E ψ)
HXe: E ≠ x
IH: fresh_svars sl
  (free_svars ψ^{evar:0↦x} ∪ free_svars p
   ∪ free_svars q)
→ length sl
  ≥ maximal_mu_depth_to sdepth E ψ^{evar:0↦x}
  → (∀ X : svar, X ∈ sl → X ∈ svs)
    → Γ
      ⊢i ψ^{evar:0↦x}^[[evar:E↦p]] <--->
         ψ^{evar:0↦x}^[[evar:E↦q]] using gpi
length sl ≥ maximal_mu_depth_to sdepth E ψ auto.
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (ex , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (ex , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
x: evar
els: list evar
Hel1: fresh_evars (x :: els)
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel3: ∀ x0 : evar, x0 ∈ x :: els → x0 ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{evar:0↦x}
H0: size' ψ^{evar:0↦x} ≤ sz
HVars: fresh_evars els
  (free_evars ψ^{evar:0↦x} ∪ free_evars p
   ∪ free_evars q ∪ {[E]})
Hel2: S (length els)
≥ S (maximal_exists_depth_to edepth E ψ)
HXe: E ≠ x
IH: fresh_svars sl
  (free_svars ψ^{evar:0↦x} ∪ free_svars p
   ∪ free_svars q)
→ length sl
  ≥ maximal_mu_depth_to sdepth E ψ^{evar:0↦x}
  → (∀ X : svar, X ∈ sl → X ∈ svs)
    → Γ
      ⊢i ψ^{evar:0↦x}^[[evar:E↦p]] <--->
         ψ^{evar:0↦x}^[[evar:E↦q]] using gpi
length sl ≥ maximal_mu_depth_to sdepth E ψ lia. }
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (ex , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (ex , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
x: evar
els: list evar
Hel1: fresh_evars (x :: els)
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel3: ∀ x0 : evar, x0 ∈ x :: els → x0 ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{evar:0↦x}
H0: size' ψ^{evar:0↦x} ≤ sz
HVars: fresh_evars els
  (free_evars ψ^{evar:0↦x} ∪ free_evars p
   ∪ free_evars q ∪ {[E]})
Hel2: S (length els)
≥ S (maximal_exists_depth_to edepth E ψ)
HXe: E ≠ x
IH: fresh_svars sl
  (free_svars ψ^{evar:0↦x} ∪ free_svars p
   ∪ free_svars q)
→ length sl
  ≥ maximal_mu_depth_to sdepth E ψ^{evar:0↦x}
  → (∀ X : svar, X ∈ sl → X ∈ svs)
    → Γ
      ⊢i ψ^{evar:0↦x}^[[evar:E↦p]] <--->
         ψ^{evar:0↦x}^[[evar:E↦q]] using gpi
∀ X : svar, X ∈ sl → X ∈ svs
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (ex , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (ex , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
x: evar
els: list evar
Hel1: fresh_evars (x :: els)
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel3: ∀ x0 : evar, x0 ∈ x :: els → x0 ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{evar:0↦x}
H0: size' ψ^{evar:0↦x} ≤ sz
HVars: fresh_evars els
  (free_evars ψ^{evar:0↦x} ∪ free_evars p
   ∪ free_evars q ∪ {[E]})
Hel2: S (length els)
≥ S (maximal_exists_depth_to edepth E ψ)
HXe: E ≠ x
IH: Γ
⊢i ψ^{evar:0↦x}^[[evar:E↦p]] <--->
   ψ^{evar:0↦x}^[[evar:E↦q]] using gpi
Γ ⊢i (ex , ψ^[[evar:E↦p]]) <---> (ex , ψ^[[evar:E↦q]])
using gpi
      {
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (ex , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (ex , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
x: evar
els: list evar
Hel1: fresh_evars (x :: els)
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel3: ∀ x0 : evar, x0 ∈ x :: els → x0 ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{evar:0↦x}
H0: size' ψ^{evar:0↦x} ≤ sz
HVars: fresh_evars els
  (free_evars ψ^{evar:0↦x} ∪ free_evars p
   ∪ free_evars q ∪ {[E]})
Hel2: S (length els)
≥ S (maximal_exists_depth_to edepth E ψ)
HXe: E ≠ x
IH: fresh_svars sl
  (free_svars ψ^{evar:0↦x} ∪ free_svars p
   ∪ free_svars q)
→ length sl
  ≥ maximal_mu_depth_to sdepth E ψ^{evar:0↦x}
  → (∀ X : svar, X ∈ sl → X ∈ svs)
    → Γ
      ⊢i ψ^{evar:0↦x}^[[evar:E↦p]] <--->
         ψ^{evar:0↦x}^[[evar:E↦q]] using gpi
∀ X : svar, X ∈ sl → X ∈ svs assumption. }
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (ex , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (ex , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
x: evar
els: list evar
Hel1: fresh_evars (x :: els)
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel3: ∀ x0 : evar, x0 ∈ x :: els → x0 ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{evar:0↦x}
H0: size' ψ^{evar:0↦x} ≤ sz
HVars: fresh_evars els
  (free_evars ψ^{evar:0↦x} ∪ free_evars p
   ∪ free_evars q ∪ {[E]})
Hel2: S (length els)
≥ S (maximal_exists_depth_to edepth E ψ)
HXe: E ≠ x
IH: Γ
⊢i ψ^{evar:0↦x}^[[evar:E↦p]] <--->
   ψ^{evar:0↦x}^[[evar:E↦q]] using gpi
Γ ⊢i (ex , ψ^[[evar:E↦p]]) <---> (ex , ψ^[[evar:E↦q]])
using gpi

      eapply congruence_ex with (x := x); try assumption.
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (ex , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (ex , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
x: evar
els: list evar
Hel1: fresh_evars (x :: els)
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel3: ∀ x0 : evar, x0 ∈ x :: els → x0 ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{evar:0↦x}
H0: size' ψ^{evar:0↦x} ≤ sz
HVars: fresh_evars els
  (free_evars ψ^{evar:0↦x} ∪ free_evars p
   ∪ free_evars q ∪ {[E]})
Hel2: S (length els)
≥ S (maximal_exists_depth_to edepth E ψ)
HXe: E ≠ x
IH: Γ
⊢i ψ^{evar:0↦x}^[[evar:E↦p]] <--->
   ψ^{evar:0↦x}^[[evar:E↦q]] using gpi
x ≠ E
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (ex , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (ex , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
x: evar
els: list evar
Hel1: fresh_evars (x :: els)
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel3: ∀ x0 : evar, x0 ∈ x :: els → x0 ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{evar:0↦x}
H0: size' ψ^{evar:0↦x} ≤ sz
HVars: fresh_evars els
  (free_evars ψ^{evar:0↦x} ∪ free_evars p
   ∪ free_evars q ∪ {[E]})
Hel2: S (length els)
≥ S (maximal_exists_depth_to edepth E ψ)
HXe: E ≠ x
IH: Γ
⊢i ψ^{evar:0↦x}^[[evar:E↦p]] <--->
   ψ^{evar:0↦x}^[[evar:E↦q]] using gpi
x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (ex , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (ex , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
x: evar
els: list evar
Hel1: fresh_evars (x :: els)
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel3: ∀ x0 : evar, x0 ∈ x :: els → x0 ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{evar:0↦x}
H0: size' ψ^{evar:0↦x} ≤ sz
HVars: fresh_evars els
  (free_evars ψ^{evar:0↦x} ∪ free_evars p
   ∪ free_evars q ∪ {[E]})
Hel2: S (length els)
≥ S (maximal_exists_depth_to edepth E ψ)
HXe: E ≠ x
IH: Γ
⊢i ψ^{evar:0↦x}^[[evar:E↦p]] <--->
   ψ^{evar:0↦x}^[[evar:E↦q]] using gpi
x ∈ ?evs
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (ex , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (ex , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
x: evar
els: list evar
Hel1: fresh_evars (x :: els)
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel3: ∀ x0 : evar, x0 ∈ x :: els → x0 ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{evar:0↦x}
H0: size' ψ^{evar:0↦x} ≤ sz
HVars: fresh_evars els
  (free_evars ψ^{evar:0↦x} ∪ free_evars p
   ∪ free_evars q ∪ {[E]})
Hel2: S (length els)
≥ S (maximal_exists_depth_to edepth E ψ)
HXe: E ≠ x
IH: Γ
⊢i ψ^{evar:0↦x}^[[evar:E↦p]] <--->
   ψ^{evar:0↦x}^[[evar:E↦q]] using gpi
ProofInfoLe
  (ExGen := ?evs, SVSubst := ?svs, KT := ?kt) gpi
      {
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (ex , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (ex , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
x: evar
els: list evar
Hel1: fresh_evars (x :: els)
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel3: ∀ x0 : evar, x0 ∈ x :: els → x0 ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{evar:0↦x}
H0: size' ψ^{evar:0↦x} ≤ sz
HVars: fresh_evars els
  (free_evars ψ^{evar:0↦x} ∪ free_evars p
   ∪ free_evars q ∪ {[E]})
Hel2: S (length els)
≥ S (maximal_exists_depth_to edepth E ψ)
HXe: E ≠ x
IH: Γ
⊢i ψ^{evar:0↦x}^[[evar:E↦p]] <--->
   ψ^{evar:0↦x}^[[evar:E↦q]] using gpi
x ≠ E
        destruct Hel1 as [_ ?].
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (ex , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (ex , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
x: evar
els: list evar
all_evars_fresh0: ∀ x0 : evar,
  x0 ∈ x :: els
  → x0
    ∉ free_evars ψ ∪ free_evars p
      ∪ free_evars q ∪ {[E]}
Hel3: ∀ x0 : evar, x0 ∈ x :: els → x0 ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{evar:0↦x}
H0: size' ψ^{evar:0↦x} ≤ sz
HVars: fresh_evars els
  (free_evars ψ^{evar:0↦x} ∪ free_evars p
   ∪ free_evars q ∪ {[E]})
Hel2: S (length els)
≥ S (maximal_exists_depth_to edepth E ψ)
HXe: E ≠ x
IH: Γ
⊢i ψ^{evar:0↦x}^[[evar:E↦p]] <--->
   ψ^{evar:0↦x}^[[evar:E↦q]] using gpi
x ≠ E
        specialize (all_evars_fresh0 x ltac:(now left)).
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (ex , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (ex , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
x: evar
els: list evar
all_evars_fresh0: x
∉ free_evars ψ ∪ free_evars p
  ∪ free_evars q ∪ {[E]}
Hel3: ∀ x0 : evar, x0 ∈ x :: els → x0 ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{evar:0↦x}
H0: size' ψ^{evar:0↦x} ≤ sz
HVars: fresh_evars els
  (free_evars ψ^{evar:0↦x} ∪ free_evars p
   ∪ free_evars q ∪ {[E]})
Hel2: S (length els)
≥ S (maximal_exists_depth_to edepth E ψ)
HXe: E ≠ x
IH: Γ
⊢i ψ^{evar:0↦x}^[[evar:E↦p]] <--->
   ψ^{evar:0↦x}^[[evar:E↦q]] using gpi
x ≠ E
        set_solver.
      }
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (ex , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (ex , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
x: evar
els: list evar
Hel1: fresh_evars (x :: els)
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel3: ∀ x0 : evar, x0 ∈ x :: els → x0 ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{evar:0↦x}
H0: size' ψ^{evar:0↦x} ≤ sz
HVars: fresh_evars els
  (free_evars ψ^{evar:0↦x} ∪ free_evars p
   ∪ free_evars q ∪ {[E]})
Hel2: S (length els)
≥ S (maximal_exists_depth_to edepth E ψ)
HXe: E ≠ x
IH: Γ
⊢i ψ^{evar:0↦x}^[[evar:E↦p]] <--->
   ψ^{evar:0↦x}^[[evar:E↦q]] using gpi
x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (ex , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (ex , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
x: evar
els: list evar
Hel1: fresh_evars (x :: els)
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel3: ∀ x0 : evar, x0 ∈ x :: els → x0 ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{evar:0↦x}
H0: size' ψ^{evar:0↦x} ≤ sz
HVars: fresh_evars els
  (free_evars ψ^{evar:0↦x} ∪ free_evars p
   ∪ free_evars q ∪ {[E]})
Hel2: S (length els)
≥ S (maximal_exists_depth_to edepth E ψ)
HXe: E ≠ x
IH: Γ
⊢i ψ^{evar:0↦x}^[[evar:E↦p]] <--->
   ψ^{evar:0↦x}^[[evar:E↦q]] using gpi
x ∈ ?evs
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (ex , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (ex , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
x: evar
els: list evar
Hel1: fresh_evars (x :: els)
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel3: ∀ x0 : evar, x0 ∈ x :: els → x0 ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{evar:0↦x}
H0: size' ψ^{evar:0↦x} ≤ sz
HVars: fresh_evars els
  (free_evars ψ^{evar:0↦x} ∪ free_evars p
   ∪ free_evars q ∪ {[E]})
Hel2: S (length els)
≥ S (maximal_exists_depth_to edepth E ψ)
HXe: E ≠ x
IH: Γ
⊢i ψ^{evar:0↦x}^[[evar:E↦p]] <--->
   ψ^{evar:0↦x}^[[evar:E↦q]] using gpi
ProofInfoLe
  (ExGen := ?evs, SVSubst := ?svs, KT := ?kt) gpi
      {
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (ex , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (ex , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
x: evar
els: list evar
Hel1: fresh_evars (x :: els)
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel3: ∀ x0 : evar, x0 ∈ x :: els → x0 ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{evar:0↦x}
H0: size' ψ^{evar:0↦x} ≤ sz
HVars: fresh_evars els
  (free_evars ψ^{evar:0↦x} ∪ free_evars p
   ∪ free_evars q ∪ {[E]})
Hel2: S (length els)
≥ S (maximal_exists_depth_to edepth E ψ)
HXe: E ≠ x
IH: Γ
⊢i ψ^{evar:0↦x}^[[evar:E↦p]] <--->
   ψ^{evar:0↦x}^[[evar:E↦q]] using gpi
x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
        destruct Hel1 as [_ ?].
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (ex , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (ex , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
x: evar
els: list evar
all_evars_fresh0: ∀ x0 : evar,
  x0 ∈ x :: els
  → x0
    ∉ free_evars ψ ∪ free_evars p
      ∪ free_evars q ∪ {[E]}
Hel3: ∀ x0 : evar, x0 ∈ x :: els → x0 ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{evar:0↦x}
H0: size' ψ^{evar:0↦x} ≤ sz
HVars: fresh_evars els
  (free_evars ψ^{evar:0↦x} ∪ free_evars p
   ∪ free_evars q ∪ {[E]})
Hel2: S (length els)
≥ S (maximal_exists_depth_to edepth E ψ)
HXe: E ≠ x
IH: Γ
⊢i ψ^{evar:0↦x}^[[evar:E↦p]] <--->
   ψ^{evar:0↦x}^[[evar:E↦q]] using gpi
x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
        specialize (all_evars_fresh0 x ltac:(now left)).
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (ex , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (ex , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
x: evar
els: list evar
all_evars_fresh0: x
∉ free_evars ψ ∪ free_evars p
  ∪ free_evars q ∪ {[E]}
Hel3: ∀ x0 : evar, x0 ∈ x :: els → x0 ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{evar:0↦x}
H0: size' ψ^{evar:0↦x} ≤ sz
HVars: fresh_evars els
  (free_evars ψ^{evar:0↦x} ∪ free_evars p
   ∪ free_evars q ∪ {[E]})
Hel2: S (length els)
≥ S (maximal_exists_depth_to edepth E ψ)
HXe: E ≠ x
IH: Γ
⊢i ψ^{evar:0↦x}^[[evar:E↦p]] <--->
   ψ^{evar:0↦x}^[[evar:E↦q]] using gpi
x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
        set_solver.
      }
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (ex , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (ex , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
x: evar
els: list evar
Hel1: fresh_evars (x :: els)
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel3: ∀ x0 : evar, x0 ∈ x :: els → x0 ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{evar:0↦x}
H0: size' ψ^{evar:0↦x} ≤ sz
HVars: fresh_evars els
  (free_evars ψ^{evar:0↦x} ∪ free_evars p
   ∪ free_evars q ∪ {[E]})
Hel2: S (length els)
≥ S (maximal_exists_depth_to edepth E ψ)
HXe: E ≠ x
IH: Γ
⊢i ψ^{evar:0↦x}^[[evar:E↦p]] <--->
   ψ^{evar:0↦x}^[[evar:E↦q]] using gpi
x ∈ ?evs
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (ex , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (ex , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
x: evar
els: list evar
Hel1: fresh_evars (x :: els)
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel3: ∀ x0 : evar, x0 ∈ x :: els → x0 ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{evar:0↦x}
H0: size' ψ^{evar:0↦x} ≤ sz
HVars: fresh_evars els
  (free_evars ψ^{evar:0↦x} ∪ free_evars p
   ∪ free_evars q ∪ {[E]})
Hel2: S (length els)
≥ S (maximal_exists_depth_to edepth E ψ)
HXe: E ≠ x
IH: Γ
⊢i ψ^{evar:0↦x}^[[evar:E↦p]] <--->
   ψ^{evar:0↦x}^[[evar:E↦q]] using gpi
ProofInfoLe
  (ExGen := ?evs, SVSubst := ?svs, KT := ?kt) gpi
      {
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (ex , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (ex , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
x: evar
els: list evar
Hel1: fresh_evars (x :: els)
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel3: ∀ x0 : evar, x0 ∈ x :: els → x0 ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{evar:0↦x}
H0: size' ψ^{evar:0↦x} ≤ sz
HVars: fresh_evars els
  (free_evars ψ^{evar:0↦x} ∪ free_evars p
   ∪ free_evars q ∪ {[E]})
Hel2: S (length els)
≥ S (maximal_exists_depth_to edepth E ψ)
HXe: E ≠ x
IH: Γ
⊢i ψ^{evar:0↦x}^[[evar:E↦p]] <--->
   ψ^{evar:0↦x}^[[evar:E↦q]] using gpi
x ∈ ?evs apply Hel3.
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (ex , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (ex , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
x: evar
els: list evar
Hel1: fresh_evars (x :: els)
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel3: ∀ x0 : evar, x0 ∈ x :: els → x0 ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{evar:0↦x}
H0: size' ψ^{evar:0↦x} ≤ sz
HVars: fresh_evars els
  (free_evars ψ^{evar:0↦x} ∪ free_evars p
   ∪ free_evars q ∪ {[E]})
Hel2: S (length els)
≥ S (maximal_exists_depth_to edepth E ψ)
HXe: E ≠ x
IH: Γ
⊢i ψ^{evar:0↦x}^[[evar:E↦p]] <--->
   ψ^{evar:0↦x}^[[evar:E↦q]] using gpi
x ∈ x :: els now left. }
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (ex , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (ex , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
x: evar
els: list evar
Hel1: fresh_evars (x :: els)
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel3: ∀ x0 : evar, x0 ∈ x :: els → x0 ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{evar:0↦x}
H0: size' ψ^{evar:0↦x} ≤ sz
HVars: fresh_evars els
  (free_evars ψ^{evar:0↦x} ∪ free_evars p
   ∪ free_evars q ∪ {[E]})
Hel2: S (length els)
≥ S (maximal_exists_depth_to edepth E ψ)
HXe: E ≠ x
IH: Γ
⊢i ψ^{evar:0↦x}^[[evar:E↦p]] <--->
   ψ^{evar:0↦x}^[[evar:E↦q]] using gpi
ProofInfoLe (ExGen := evs, SVSubst := ?svs, KT := ?kt)
  gpi
      {
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (ex , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (ex , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
x: evar
els: list evar
Hel1: fresh_evars (x :: els)
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel3: ∀ x0 : evar, x0 ∈ x :: els → x0 ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{evar:0↦x}
H0: size' ψ^{evar:0↦x} ≤ sz
HVars: fresh_evars els
  (free_evars ψ^{evar:0↦x} ∪ free_evars p
   ∪ free_evars q ∪ {[E]})
Hel2: S (length els)
≥ S (maximal_exists_depth_to edepth E ψ)
HXe: E ≠ x
IH: Γ
⊢i ψ^{evar:0↦x}^[[evar:E↦p]] <--->
   ψ^{evar:0↦x}^[[evar:E↦q]] using gpi
ProofInfoLe (ExGen := evs, SVSubst := ?svs, KT := ?kt)
  gpi eapply pile_trans;[|apply pile].
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (ex , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (ex , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
x: evar
els: list evar
Hel1: fresh_evars (x :: els)
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel3: ∀ x0 : evar, x0 ∈ x :: els → x0 ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{evar:0↦x}
H0: size' ψ^{evar:0↦x} ≤ sz
HVars: fresh_evars els
  (free_evars ψ^{evar:0↦x} ∪ free_evars p
   ∪ free_evars q ∪ {[E]})
Hel2: S (length els)
≥ S (maximal_exists_depth_to edepth E ψ)
HXe: E ≠ x
IH: Γ
⊢i ψ^{evar:0↦x}^[[evar:E↦p]] <--->
   ψ^{evar:0↦x}^[[evar:E↦q]] using gpi
ProofInfoLe (ExGen := evs, SVSubst := ?svs, KT := ?kt)
  i'
        unfold i'.
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (ex , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (ex , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
x: evar
els: list evar
Hel1: fresh_evars (x :: els)
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel3: ∀ x0 : evar, x0 ∈ x :: els → x0 ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{evar:0↦x}
H0: size' ψ^{evar:0↦x} ≤ sz
HVars: fresh_evars els
  (free_evars ψ^{evar:0↦x} ∪ free_evars p
   ∪ free_evars q ∪ {[E]})
Hel2: S (length els)
≥ S (maximal_exists_depth_to edepth E ψ)
HXe: E ≠ x
IH: Γ
⊢i ψ^{evar:0↦x}^[[evar:E↦p]] <--->
   ψ^{evar:0↦x}^[[evar:E↦q]] using gpi
ProofInfoLe (ExGen := evs, SVSubst := ?svs, KT := ?kt)
  (ExGen := evs, SVSubst := svs,
   KT := mu_in_evar_path E (ex , ψ) sdepth) now apply pile_refl.
      }
    }
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (mu , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars (mu , ψ) ∪ free_evars p
   ∪ free_evars q ∪ {[E]})
Hel2: length el
≥ maximal_exists_depth_to edepth E (mu , ψ)
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars (mu , ψ) ∪ free_svars p
   ∪ free_svars q)
Hsl2: length sl
≥ maximal_mu_depth_to sdepth E (mu , ψ)
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars (mu , ψ)
Γ ⊢i (mu , ψ^[[evar:E↦p]]) <---> (mu , ψ^[[evar:E↦q]])
using gpi
    {
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (mu , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars (mu , ψ) ∪ free_evars p
   ∪ free_evars q ∪ {[E]})
Hel2: length el
≥ maximal_exists_depth_to edepth E (mu , ψ)
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl
  (free_svars (mu , ψ) ∪ free_svars p
   ∪ free_svars q)
Hsl2: length sl
≥ maximal_mu_depth_to sdepth E (mu , ψ)
Hsl3: ∀ X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars (mu , ψ)
Γ ⊢i (mu , ψ^[[evar:E↦p]]) <---> (mu , ψ^[[evar:E↦q]])
using gpi
      destruct sl as [ | X sls].
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (mu , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars (mu , ψ) ∪ free_evars p
   ∪ free_evars q ∪ {[E]})
Hel2: length el
≥ maximal_exists_depth_to edepth E (mu , ψ)
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
Hsl1: fresh_svars []
  (free_svars (mu , ψ) ∪ free_svars p
   ∪ free_svars q)
Hsl2: length []
≥ maximal_mu_depth_to sdepth E (mu , ψ)
Hsl3: ∀ X : svar, X ∈ [] → X ∈ svs
HEinψ: E ∈ free_evars (mu , ψ)
Γ ⊢i (mu , ψ^[[evar:E↦p]]) <---> (mu , ψ^[[evar:E↦q]])
using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (mu , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars (mu , ψ) ∪ free_evars p
   ∪ free_evars q ∪ {[E]})
Hel2: length el
≥ maximal_exists_depth_to edepth E (mu , ψ)
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls)
  (free_svars (mu , ψ) ∪ free_svars p
   ∪ free_svars q)
Hsl2: length (X :: sls)
≥ maximal_mu_depth_to sdepth E (mu , ψ)
Hsl3: ∀ X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars (mu , ψ)
Γ ⊢i (mu , ψ^[[evar:E↦p]]) <---> (mu , ψ^[[evar:E↦q]])
using gpi
      {
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (mu , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars (mu , ψ) ∪ free_evars p
   ∪ free_evars q ∪ {[E]})
Hel2: length el
≥ maximal_exists_depth_to edepth E (mu , ψ)
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
Hsl1: fresh_svars []
  (free_svars (mu , ψ) ∪ free_svars p
   ∪ free_svars q)
Hsl2: length []
≥ maximal_mu_depth_to sdepth E (mu , ψ)
Hsl3: ∀ X : svar, X ∈ [] → X ∈ svs
HEinψ: E ∈ free_evars (mu , ψ)
Γ ⊢i (mu , ψ^[[evar:E↦p]]) <---> (mu , ψ^[[evar:E↦q]])
using gpi
        simpl in Hsl2.
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (mu , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars (mu , ψ) ∪ free_evars p
   ∪ free_evars q ∪ {[E]})
Hel2: length el
≥ maximal_exists_depth_to edepth E (mu , ψ)
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
Hsl1: fresh_svars []
  (free_svars (mu , ψ) ∪ free_svars p
   ∪ free_svars q)
Hsl2: 0 ≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: ∀ X : svar, X ∈ [] → X ∈ svs
HEinψ: E ∈ free_evars (mu , ψ)
Γ ⊢i (mu , ψ^[[evar:E↦p]]) <---> (mu , ψ^[[evar:E↦q]])
using gpi
        rewrite maximal_mu_depth_to_S in Hsl2.
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (mu , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars (mu , ψ) ∪ free_evars p
   ∪ free_evars q ∪ {[E]})
Hel2: length el
≥ maximal_exists_depth_to edepth E (mu , ψ)
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
Hsl1: fresh_svars []
  (free_svars (mu , ψ) ∪ free_svars p
   ∪ free_svars q)
Hsl3: ∀ X : svar, X ∈ [] → X ∈ svs
HEinψ: E ∈ free_evars (mu , ψ)
E ∈ free_evars ψ
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (mu , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars (mu , ψ) ∪ free_evars p
   ∪ free_evars q ∪ {[E]})
Hel2: length el
≥ maximal_exists_depth_to edepth E (mu , ψ)
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
Hsl1: fresh_svars []
  (free_svars (mu , ψ) ∪ free_svars p
   ∪ free_svars q)
Hsl3: ∀ X : svar, X ∈ [] → X ∈ svs
HEinψ: E ∈ free_evars (mu , ψ)
Hsl2: 0 ≥ S (maximal_mu_depth_to sdepth E ψ)
Γ ⊢i (mu , ψ^[[evar:E↦p]]) <---> (mu , ψ^[[evar:E↦q]])
using gpi assumption.
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (mu , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars (mu , ψ) ∪ free_evars p
   ∪ free_evars q ∪ {[E]})
Hel2: length el
≥ maximal_exists_depth_to edepth E (mu , ψ)
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
Hsl1: fresh_svars []
  (free_svars (mu , ψ) ∪ free_svars p
   ∪ free_svars q)
Hsl3: ∀ X : svar, X ∈ [] → X ∈ svs
HEinψ: E ∈ free_evars (mu , ψ)
Hsl2: 0 ≥ S (maximal_mu_depth_to sdepth E ψ)
Γ ⊢i (mu , ψ^[[evar:E↦p]]) <---> (mu , ψ^[[evar:E↦q]])
using gpi lia.
      }
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (mu , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars (mu , ψ) ∪ free_evars p
   ∪ free_evars q ∪ {[E]})
Hel2: length el
≥ maximal_exists_depth_to edepth E (mu , ψ)
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls)
  (free_svars (mu , ψ) ∪ free_svars p
   ∪ free_svars q)
Hsl2: length (X :: sls)
≥ maximal_mu_depth_to sdepth E (mu , ψ)
Hsl3: ∀ X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars (mu , ψ)
Γ ⊢i (mu , ψ^[[evar:E↦p]]) <---> (mu , ψ^[[evar:E↦q]])
using gpi

      assert (well_formed (ψ^{svar: 0 ↦ X}) = true) by (abstract(clear -wfψ;wf_auto2)).
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (mu , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars (mu , ψ) ∪ free_evars p
   ∪ free_evars q ∪ {[E]})
Hel2: length el
≥ maximal_exists_depth_to edepth E (mu , ψ)
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls)
  (free_svars (mu , ψ) ∪ free_svars p
   ∪ free_svars q)
Hsl2: length (X :: sls)
≥ maximal_mu_depth_to sdepth E (mu , ψ)
Hsl3: ∀ X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars (mu , ψ)
H: well_formed ψ^{svar:0↦X} = true
Γ ⊢i (mu , ψ^[[evar:E↦p]]) <---> (mu , ψ^[[evar:E↦q]])
using gpi
      assert (size' (ψ^{svar: 0 ↦ X}) <= sz) by abstract(rewrite svar_open_size'; lia).
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (mu , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars (mu , ψ) ∪ free_evars p
   ∪ free_evars q ∪ {[E]})
Hel2: length el
≥ maximal_exists_depth_to edepth E (mu , ψ)
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls)
  (free_svars (mu , ψ) ∪ free_svars p
   ∪ free_svars q)
Hsl2: length (X :: sls)
≥ maximal_mu_depth_to sdepth E (mu , ψ)
Hsl3: ∀ X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars (mu , ψ)
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
Γ ⊢i (mu , ψ^[[evar:E↦p]]) <---> (mu , ψ^[[evar:E↦q]])
using gpi

      simpl in *.
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs,
KT := mu_in_evar_path E (mu , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls)
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls)
≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: ∀ X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
Γ ⊢i (mu , ψ^[[evar:E↦p]]) <---> (mu , ψ^[[evar:E↦q]])
using gpi

      subst i'.
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs,
   KT := mu_in_evar_path E (mu , ψ) sdepth) gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls)
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls)
≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: ∀ X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
Γ ⊢i (mu , ψ^[[evar:E↦p]]) <---> (mu , ψ^[[evar:E↦q]])
using gpi
      cbn in *.
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := mu_in_evar_path E ψ sdepth)
          gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs,
   KT := mu_in_evar_path E (mu , ψ) sdepth) gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls)
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls)
≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: ∀ X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
Γ ⊢i (mu , ψ^[[evar:E↦p]]) <---> (mu , ψ^[[evar:E↦q]])
using gpi unfold mu_in_evar_path in *.
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := ~~
                 (0 =?
                  maximal_mu_depth_to sdepth E
                    ψ)%nat) gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs,
   KT := ~~
         (0 =?
          maximal_mu_depth_to sdepth E (mu , ψ))%nat)
  gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls)
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls)
≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: ∀ X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
Γ ⊢i (mu , ψ^[[evar:E↦p]]) <---> (mu , ψ^[[evar:E↦q]])
using gpi cbn in *.
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := ~~
                 match
                   maximal_mu_depth_to sdepth E
                     ψ
                 with
                 | 0 => true
                 | S _ => false
                 end) gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs,
   KT := ~~
         match
           maximal_mu_depth_to (S sdepth) E ψ
         with
         | 0 => true
         | S _ => false
         end) gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls)
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls)
≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: ∀ X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
Γ ⊢i (mu , ψ^[[evar:E↦p]]) <---> (mu , ψ^[[evar:E↦q]])
using gpi
      rewrite maximal_mu_depth_to_S in pile.
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := ~~
                 match
                   maximal_mu_depth_to sdepth E
                     ψ
                 with
                 | 0 => true
                 | S _ => false
                 end) gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls)
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls)
≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: ∀ X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
E ∈ free_evars ψ
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := ~~
                 match
                   maximal_mu_depth_to sdepth E
                     ψ
                 with
                 | 0 => true
                 | S _ => false
                 end) gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls)
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls)
≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: ∀ X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := ~~ false)
  gpi
Γ ⊢i (mu , ψ^[[evar:E↦p]]) <---> (mu , ψ^[[evar:E↦q]])
using gpi assumption.
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := ~~
                 match
                   maximal_mu_depth_to sdepth E
                     ψ
                 with
                 | 0 => true
                 | S _ => false
                 end) gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls)
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls)
≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: ∀ X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := ~~ false)
  gpi
Γ ⊢i (mu , ψ^[[evar:E↦p]]) <---> (mu , ψ^[[evar:E↦q]])
using gpi

      unshelve (epose proof (IH := IHsz edepth sdepth (ψ^{svar: 0 ↦ X}) ltac:(assumption) ltac:(assumption) evs svs gpi _ pf el)).
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := ~~
                 match
                   maximal_mu_depth_to sdepth E
                     ψ
                 with
                 | 0 => true
                 | S _ => false
                 end) gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls)
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls)
≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: ∀ X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := ~~ false)
  gpi
ProofInfoLe
  (ExGen := evs, SVSubst := svs,
   KT := ~~
         match
           maximal_mu_depth_to sdepth E ψ^{svar:0↦X}
         with
         | 0 => true
         | S _ => false
         end) gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := ~~
                 match
                   maximal_mu_depth_to sdepth E
                     ψ
                 with
                 | 0 => true
                 | S _ => false
                 end) gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls)
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls)
≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: ∀ X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := ~~ false)
  gpi
IH: fresh_evars el
  (free_evars ψ^{svar:0↦X} ∪ free_evars p
   ∪ free_evars q ∪ {[E]})
→ length el
  ≥ maximal_exists_depth_to edepth E ψ^{svar:0↦X}
  → (∀ x : evar, x ∈ el → x ∈ evs)
    → ∀ sl : list svar,
        fresh_svars sl
          (free_svars ψ^{svar:0↦X} ∪ free_svars p
           ∪ free_svars q)
        → length sl
          ≥ maximal_mu_depth_to sdepth E
              ψ^{svar:0↦X}
          → (∀ X : svar, X ∈ sl → X ∈ svs)
            → Γ
              ⊢i ψ^{svar:0↦X}^[[evar:E↦p]] <--->
                 ψ^{svar:0↦X}^[[evar:E↦q]]
              using gpi
Γ ⊢i (mu , ψ^[[evar:E↦p]]) <---> (mu , ψ^[[evar:E↦q]])
using gpi
      {
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := ~~
                 match
                   maximal_mu_depth_to sdepth E
                     ψ
                 with
                 | 0 => true
                 | S _ => false
                 end) gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls)
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls)
≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: ∀ X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := ~~ false)
  gpi
ProofInfoLe
  (ExGen := evs, SVSubst := svs,
   KT := ~~
         match
           maximal_mu_depth_to sdepth E ψ^{svar:0↦X}
         with
         | 0 => true
         | S _ => false
         end) gpi 
        try_solve_pile.
      }
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := ~~
                 match
                   maximal_mu_depth_to sdepth E
                     ψ
                 with
                 | 0 => true
                 | S _ => false
                 end) gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls)
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls)
≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: ∀ X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := ~~ false)
  gpi
IH: fresh_evars el
  (free_evars ψ^{svar:0↦X} ∪ free_evars p
   ∪ free_evars q ∪ {[E]})
→ length el
  ≥ maximal_exists_depth_to edepth E ψ^{svar:0↦X}
  → (∀ x : evar, x ∈ el → x ∈ evs)
    → ∀ sl : list svar,
        fresh_svars sl
          (free_svars ψ^{svar:0↦X} ∪ free_svars p
           ∪ free_svars q)
        → length sl
          ≥ maximal_mu_depth_to sdepth E
              ψ^{svar:0↦X}
          → (∀ X : svar, X ∈ sl → X ∈ svs)
            → Γ
              ⊢i ψ^{svar:0↦X}^[[evar:E↦p]] <--->
                 ψ^{svar:0↦X}^[[evar:E↦q]]
              using gpi
Γ ⊢i (mu , ψ^[[evar:E↦p]]) <---> (mu , ψ^[[evar:E↦q]])
using gpi
      feed specialize IH.
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := ~~
                 match
                   maximal_mu_depth_to sdepth E
                     ψ
                 with
                 | 0 => true
                 | S _ => false
                 end) gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls)
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls)
≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: ∀ X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := ~~ false)
  gpi
IH: fresh_evars el
  (free_evars ψ^{svar:0↦X} ∪ free_evars p
   ∪ free_evars q ∪ {[E]})
→ length el
  ≥ maximal_exists_depth_to edepth E ψ^{svar:0↦X}
  → (∀ x : evar, x ∈ el → x ∈ evs)
    → ∀ sl : list svar,
        fresh_svars sl
          (free_svars ψ^{svar:0↦X} ∪ free_svars p
           ∪ free_svars q)
        → length sl
          ≥ maximal_mu_depth_to sdepth E
              ψ^{svar:0↦X}
          → (∀ X : svar, X ∈ sl → X ∈ svs)
            → Γ
              ⊢i ψ^{svar:0↦X}^[[evar:E↦p]] <--->
                 ψ^{svar:0↦X}^[[evar:E↦q]]
              using gpi
fresh_evars el
  (free_evars ψ^{svar:0↦X} ∪ free_evars p
   ∪ free_evars q ∪ {[E]})
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := ~~
                 match
                   maximal_mu_depth_to sdepth E
                     ψ
                 with
                 | 0 => true
                 | S _ => false
                 end) gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls)
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls)
≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: ∀ X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := ~~ false)
  gpi
IH: fresh_evars el
  (free_evars ψ^{svar:0↦X} ∪ free_evars p
   ∪ free_evars q ∪ {[E]})
→ length el
  ≥ maximal_exists_depth_to edepth E ψ^{svar:0↦X}
  → (∀ x : evar, x ∈ el → x ∈ evs)
    → ∀ sl : list svar,
        fresh_svars sl
          (free_svars ψ^{svar:0↦X} ∪ free_svars p
           ∪ free_svars q)
        → length sl
          ≥ maximal_mu_depth_to sdepth E
              ψ^{svar:0↦X}
          → (∀ X : svar, X ∈ sl → X ∈ svs)
            → Γ
              ⊢i ψ^{svar:0↦X}^[[evar:E↦p]] <--->
                 ψ^{svar:0↦X}^[[evar:E↦q]]
              using gpi
length el
≥ maximal_exists_depth_to edepth E ψ^{svar:0↦X}
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := ~~
                 match
                   maximal_mu_depth_to sdepth E
                     ψ
                 with
                 | 0 => true
                 | S _ => false
                 end) gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls)
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls)
≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: ∀ X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := ~~ false)
  gpi
IH: fresh_evars el
  (free_evars ψ^{svar:0↦X} ∪ free_evars p
   ∪ free_evars q ∪ {[E]})
→ length el
  ≥ maximal_exists_depth_to edepth E ψ^{svar:0↦X}
  → (∀ x : evar, x ∈ el → x ∈ evs)
    → ∀ sl : list svar,
        fresh_svars sl
          (free_svars ψ^{svar:0↦X} ∪ free_svars p
           ∪ free_svars q)
        → length sl
          ≥ maximal_mu_depth_to sdepth E
              ψ^{svar:0↦X}
          → (∀ X : svar, X ∈ sl → X ∈ svs)
            → Γ
              ⊢i ψ^{svar:0↦X}^[[evar:E↦p]] <--->
                 ψ^{svar:0↦X}^[[evar:E↦q]]
              using gpi
∀ x : evar, x ∈ el → x ∈ evs
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := ~~
                 match
                   maximal_mu_depth_to sdepth E
                     ψ
                 with
                 | 0 => true
                 | S _ => false
                 end) gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls)
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls)
≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: ∀ X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := ~~ false)
  gpi
IH: ∀ sl : list svar,
  fresh_svars sl
    (free_svars ψ^{svar:0↦X} ∪ free_svars p
     ∪ free_svars q)
  → length sl
    ≥ maximal_mu_depth_to sdepth E ψ^{svar:0↦X}
    → (∀ X : svar, X ∈ sl → X ∈ svs)
      → Γ
        ⊢i ψ^{svar:0↦X}^[[evar:E↦p]] <--->
           ψ^{svar:0↦X}^[[evar:E↦q]] using gpi
Γ ⊢i (mu , ψ^[[evar:E↦p]]) <---> (mu , ψ^[[evar:E↦q]])
using gpi
      {
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := ~~
                 match
                   maximal_mu_depth_to sdepth E
                     ψ
                 with
                 | 0 => true
                 | S _ => false
                 end) gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls)
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls)
≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: ∀ X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := ~~ false)
  gpi
IH: fresh_evars el
  (free_evars ψ^{svar:0↦X} ∪ free_evars p
   ∪ free_evars q ∪ {[E]})
→ length el
  ≥ maximal_exists_depth_to edepth E ψ^{svar:0↦X}
  → (∀ x : evar, x ∈ el → x ∈ evs)
    → ∀ sl : list svar,
        fresh_svars sl
          (free_svars ψ^{svar:0↦X} ∪ free_svars p
           ∪ free_svars q)
        → length sl
          ≥ maximal_mu_depth_to sdepth E
              ψ^{svar:0↦X}
          → (∀ X : svar, X ∈ sl → X ∈ svs)
            → Γ
              ⊢i ψ^{svar:0↦X}^[[evar:E↦p]] <--->
                 ψ^{svar:0↦X}^[[evar:E↦q]]
              using gpi
fresh_evars el
  (free_evars ψ^{svar:0↦X} ∪ free_evars p
   ∪ free_evars q ∪ {[E]})
        now rewrite free_evars_svar_open.
      }
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := ~~
                 match
                   maximal_mu_depth_to sdepth E
                     ψ
                 with
                 | 0 => true
                 | S _ => false
                 end) gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls)
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls)
≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: ∀ X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := ~~ false)
  gpi
IH: fresh_evars el
  (free_evars ψ^{svar:0↦X} ∪ free_evars p
   ∪ free_evars q ∪ {[E]})
→ length el
  ≥ maximal_exists_depth_to edepth E ψ^{svar:0↦X}
  → (∀ x : evar, x ∈ el → x ∈ evs)
    → ∀ sl : list svar,
        fresh_svars sl
          (free_svars ψ^{svar:0↦X} ∪ free_svars p
           ∪ free_svars q)
        → length sl
          ≥ maximal_mu_depth_to sdepth E
              ψ^{svar:0↦X}
          → (∀ X : svar, X ∈ sl → X ∈ svs)
            → Γ
              ⊢i ψ^{svar:0↦X}^[[evar:E↦p]] <--->
                 ψ^{svar:0↦X}^[[evar:E↦q]]
              using gpi
length el
≥ maximal_exists_depth_to edepth E ψ^{svar:0↦X}
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := ~~
                 match
                   maximal_mu_depth_to sdepth E
                     ψ
                 with
                 | 0 => true
                 | S _ => false
                 end) gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls)
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls)
≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: ∀ X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := ~~ false)
  gpi
IH: fresh_evars el
  (free_evars ψ^{svar:0↦X} ∪ free_evars p
   ∪ free_evars q ∪ {[E]})
→ length el
  ≥ maximal_exists_depth_to edepth E ψ^{svar:0↦X}
  → (∀ x : evar, x ∈ el → x ∈ evs)
    → ∀ sl : list svar,
        fresh_svars sl
          (free_svars ψ^{svar:0↦X} ∪ free_svars p
           ∪ free_svars q)
        → length sl
          ≥ maximal_mu_depth_to sdepth E
              ψ^{svar:0↦X}
          → (∀ X : svar, X ∈ sl → X ∈ svs)
            → Γ
              ⊢i ψ^{svar:0↦X}^[[evar:E↦p]] <--->
                 ψ^{svar:0↦X}^[[evar:E↦q]]
              using gpi
∀ x : evar, x ∈ el → x ∈ evs
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := ~~
                 match
                   maximal_mu_depth_to sdepth E
                     ψ
                 with
                 | 0 => true
                 | S _ => false
                 end) gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls)
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls)
≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: ∀ X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := ~~ false)
  gpi
IH: ∀ sl : list svar,
  fresh_svars sl
    (free_svars ψ^{svar:0↦X} ∪ free_svars p
     ∪ free_svars q)
  → length sl
    ≥ maximal_mu_depth_to sdepth E ψ^{svar:0↦X}
    → (∀ X : svar, X ∈ sl → X ∈ svs)
      → Γ
        ⊢i ψ^{svar:0↦X}^[[evar:E↦p]] <--->
           ψ^{svar:0↦X}^[[evar:E↦q]] using gpi
Γ ⊢i (mu , ψ^[[evar:E↦p]]) <---> (mu , ψ^[[evar:E↦q]])
using gpi
      {
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := ~~
                 match
                   maximal_mu_depth_to sdepth E
                     ψ
                 with
                 | 0 => true
                 | S _ => false
                 end) gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls)
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls)
≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: ∀ X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := ~~ false)
  gpi
IH: fresh_evars el
  (free_evars ψ^{svar:0↦X} ∪ free_evars p
   ∪ free_evars q ∪ {[E]})
→ length el
  ≥ maximal_exists_depth_to edepth E ψ^{svar:0↦X}
  → (∀ x : evar, x ∈ el → x ∈ evs)
    → ∀ sl : list svar,
        fresh_svars sl
          (free_svars ψ^{svar:0↦X} ∪ free_svars p
           ∪ free_svars q)
        → length sl
          ≥ maximal_mu_depth_to sdepth E
              ψ^{svar:0↦X}
          → (∀ X : svar, X ∈ sl → X ∈ svs)
            → Γ
              ⊢i ψ^{svar:0↦X}^[[evar:E↦p]] <--->
                 ψ^{svar:0↦X}^[[evar:E↦q]]
              using gpi
length el
≥ maximal_exists_depth_to edepth E ψ^{svar:0↦X}
        rewrite svar_open_exists_depth.
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := ~~
                 match
                   maximal_mu_depth_to sdepth E
                     ψ
                 with
                 | 0 => true
                 | S _ => false
                 end) gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls)
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls)
≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: ∀ X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := ~~ false)
  gpi
IH: fresh_evars el
  (free_evars ψ^{svar:0↦X} ∪ free_evars p
   ∪ free_evars q ∪ {[E]})
→ length el
  ≥ maximal_exists_depth_to edepth E ψ^{svar:0↦X}
  → (∀ x : evar, x ∈ el → x ∈ evs)
    → ∀ sl : list svar,
        fresh_svars sl
          (free_svars ψ^{svar:0↦X} ∪ free_svars p
           ∪ free_svars q)
        → length sl
          ≥ maximal_mu_depth_to sdepth E
              ψ^{svar:0↦X}
          → (∀ X : svar, X ∈ sl → X ∈ svs)
            → Γ
              ⊢i ψ^{svar:0↦X}^[[evar:E↦p]] <--->
                 ψ^{svar:0↦X}^[[evar:E↦q]]
              using gpi
length el ≥ maximal_exists_depth_to edepth E ψ lia.
      }
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := ~~
                 match
                   maximal_mu_depth_to sdepth E
                     ψ
                 with
                 | 0 => true
                 | S _ => false
                 end) gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls)
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls)
≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: ∀ X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := ~~ false)
  gpi
IH: fresh_evars el
  (free_evars ψ^{svar:0↦X} ∪ free_evars p
   ∪ free_evars q ∪ {[E]})
→ length el
  ≥ maximal_exists_depth_to edepth E ψ^{svar:0↦X}
  → (∀ x : evar, x ∈ el → x ∈ evs)
    → ∀ sl : list svar,
        fresh_svars sl
          (free_svars ψ^{svar:0↦X} ∪ free_svars p
           ∪ free_svars q)
        → length sl
          ≥ maximal_mu_depth_to sdepth E
              ψ^{svar:0↦X}
          → (∀ X : svar, X ∈ sl → X ∈ svs)
            → Γ
              ⊢i ψ^{svar:0↦X}^[[evar:E↦p]] <--->
                 ψ^{svar:0↦X}^[[evar:E↦q]]
              using gpi
∀ x : evar, x ∈ el → x ∈ evs
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := ~~
                 match
                   maximal_mu_depth_to sdepth E
                     ψ
                 with
                 | 0 => true
                 | S _ => false
                 end) gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls)
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls)
≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: ∀ X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := ~~ false)
  gpi
IH: ∀ sl : list svar,
  fresh_svars sl
    (free_svars ψ^{svar:0↦X} ∪ free_svars p
     ∪ free_svars q)
  → length sl
    ≥ maximal_mu_depth_to sdepth E ψ^{svar:0↦X}
    → (∀ X : svar, X ∈ sl → X ∈ svs)
      → Γ
        ⊢i ψ^{svar:0↦X}^[[evar:E↦p]] <--->
           ψ^{svar:0↦X}^[[evar:E↦q]] using gpi
Γ ⊢i (mu , ψ^[[evar:E↦p]]) <---> (mu , ψ^[[evar:E↦q]])
using gpi
      {
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := ~~
                 match
                   maximal_mu_depth_to sdepth E
                     ψ
                 with
                 | 0 => true
                 | S _ => false
                 end) gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls)
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls)
≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: ∀ X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := ~~ false)
  gpi
IH: fresh_evars el
  (free_evars ψ^{svar:0↦X} ∪ free_evars p
   ∪ free_evars q ∪ {[E]})
→ length el
  ≥ maximal_exists_depth_to edepth E ψ^{svar:0↦X}
  → (∀ x : evar, x ∈ el → x ∈ evs)
    → ∀ sl : list svar,
        fresh_svars sl
          (free_svars ψ^{svar:0↦X} ∪ free_svars p
           ∪ free_svars q)
        → length sl
          ≥ maximal_mu_depth_to sdepth E
              ψ^{svar:0↦X}
          → (∀ X : svar, X ∈ sl → X ∈ svs)
            → Γ
              ⊢i ψ^{svar:0↦X}^[[evar:E↦p]] <--->
                 ψ^{svar:0↦X}^[[evar:E↦q]]
              using gpi
∀ x : evar, x ∈ el → x ∈ evs
        assumption.
      }
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := ~~
                 match
                   maximal_mu_depth_to sdepth E
                     ψ
                 with
                 | 0 => true
                 | S _ => false
                 end) gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls)
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls)
≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: ∀ X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := ~~ false)
  gpi
IH: ∀ sl : list svar,
  fresh_svars sl
    (free_svars ψ^{svar:0↦X} ∪ free_svars p
     ∪ free_svars q)
  → length sl
    ≥ maximal_mu_depth_to sdepth E ψ^{svar:0↦X}
    → (∀ X : svar, X ∈ sl → X ∈ svs)
      → Γ
        ⊢i ψ^{svar:0↦X}^[[evar:E↦p]] <--->
           ψ^{svar:0↦X}^[[evar:E↦q]] using gpi
Γ ⊢i (mu , ψ^[[evar:E↦p]]) <---> (mu , ψ^[[evar:E↦q]])
using gpi
      specialize (IH sls).
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := ~~
                 match
                   maximal_mu_depth_to sdepth E
                     ψ
                 with
                 | 0 => true
                 | S _ => false
                 end) gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls)
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls)
≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: ∀ X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := ~~ false)
  gpi
IH: fresh_svars sls
  (free_svars ψ^{svar:0↦X} ∪ free_svars p
   ∪ free_svars q)
→ length sls
  ≥ maximal_mu_depth_to sdepth E ψ^{svar:0↦X}
  → (∀ X : svar, X ∈ sls → X ∈ svs)
    → Γ
      ⊢i ψ^{svar:0↦X}^[[evar:E↦p]] <--->
         ψ^{svar:0↦X}^[[evar:E↦q]] using gpi
Γ ⊢i (mu , ψ^[[evar:E↦p]]) <---> (mu , ψ^[[evar:E↦q]])
using gpi
      feed specialize IH.
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := ~~
                 match
                   maximal_mu_depth_to sdepth E
                     ψ
                 with
                 | 0 => true
                 | S _ => false
                 end) gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls)
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls)
≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: ∀ X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := ~~ false)
  gpi
IH: fresh_svars sls
  (free_svars ψ^{svar:0↦X} ∪ free_svars p
   ∪ free_svars q)
→ length sls
  ≥ maximal_mu_depth_to sdepth E ψ^{svar:0↦X}
  → (∀ X : svar, X ∈ sls → X ∈ svs)
    → Γ
      ⊢i ψ^{svar:0↦X}^[[evar:E↦p]] <--->
         ψ^{svar:0↦X}^[[evar:E↦q]] using gpi
fresh_svars sls
  (free_svars ψ^{svar:0↦X} ∪ free_svars p
   ∪ free_svars q)
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := ~~
                 match
                   maximal_mu_depth_to sdepth E
                     ψ
                 with
                 | 0 => true
                 | S _ => false
                 end) gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls)
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls)
≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: ∀ X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := ~~ false)
  gpi
IH: fresh_svars sls
  (free_svars ψ^{svar:0↦X} ∪ free_svars p
   ∪ free_svars q)
→ length sls
  ≥ maximal_mu_depth_to sdepth E ψ^{svar:0↦X}
  → (∀ X : svar, X ∈ sls → X ∈ svs)
    → Γ
      ⊢i ψ^{svar:0↦X}^[[evar:E↦p]] <--->
         ψ^{svar:0↦X}^[[evar:E↦q]] using gpi
length sls ≥ maximal_mu_depth_to sdepth E ψ^{svar:0↦X}
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := ~~
                 match
                   maximal_mu_depth_to sdepth E
                     ψ
                 with
                 | 0 => true
                 | S _ => false
                 end) gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls)
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls)
≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: ∀ X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := ~~ false)
  gpi
IH: fresh_svars sls
  (free_svars ψ^{svar:0↦X} ∪ free_svars p
   ∪ free_svars q)
→ length sls
  ≥ maximal_mu_depth_to sdepth E ψ^{svar:0↦X}
  → (∀ X : svar, X ∈ sls → X ∈ svs)
    → Γ
      ⊢i ψ^{svar:0↦X}^[[evar:E↦p]] <--->
         ψ^{svar:0↦X}^[[evar:E↦q]] using gpi
∀ X : svar, X ∈ sls → X ∈ svs
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := ~~
                 match
                   maximal_mu_depth_to sdepth E
                     ψ
                 with
                 | 0 => true
                 | S _ => false
                 end) gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls)
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls)
≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: ∀ X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := ~~ false)
  gpi
IH: Γ
⊢i ψ^{svar:0↦X}^[[evar:E↦p]] <--->
   ψ^{svar:0↦X}^[[evar:E↦q]] using gpi
Γ ⊢i (mu , ψ^[[evar:E↦p]]) <---> (mu , ψ^[[evar:E↦q]])
using gpi
      {
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := ~~
                 match
                   maximal_mu_depth_to sdepth E
                     ψ
                 with
                 | 0 => true
                 | S _ => false
                 end) gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls)
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls)
≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: ∀ X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := ~~ false)
  gpi
IH: fresh_svars sls
  (free_svars ψ^{svar:0↦X} ∪ free_svars p
   ∪ free_svars q)
→ length sls
  ≥ maximal_mu_depth_to sdepth E ψ^{svar:0↦X}
  → (∀ X : svar, X ∈ sls → X ∈ svs)
    → Γ
      ⊢i ψ^{svar:0↦X}^[[evar:E↦p]] <--->
         ψ^{svar:0↦X}^[[evar:E↦q]] using gpi
fresh_svars sls
  (free_svars ψ^{svar:0↦X} ∪ free_svars p
   ∪ free_svars q)
        constructor.
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := ~~
                 match
                   maximal_mu_depth_to sdepth E
                     ψ
                 with
                 | 0 => true
                 | S _ => false
                 end) gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls)
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls)
≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: ∀ X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := ~~ false)
  gpi
IH: fresh_svars sls
  (free_svars ψ^{svar:0↦X} ∪ free_svars p
   ∪ free_svars q)
→ length sls
  ≥ maximal_mu_depth_to sdepth E ψ^{svar:0↦X}
  → (∀ X : svar, X ∈ sls → X ∈ svs)
    → Γ
      ⊢i ψ^{svar:0↦X}^[[evar:E↦p]] <--->
         ψ^{svar:0↦X}^[[evar:E↦q]] using gpi
no_dups sls
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := ~~
                 match
                   maximal_mu_depth_to sdepth E
                     ψ
                 with
                 | 0 => true
                 | S _ => false
                 end) gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls)
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls)
≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: ∀ X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := ~~ false)
  gpi
IH: fresh_svars sls
  (free_svars ψ^{svar:0↦X} ∪ free_svars p
   ∪ free_svars q)
→ length sls
  ≥ maximal_mu_depth_to sdepth E ψ^{svar:0↦X}
  → (∀ X : svar, X ∈ sls → X ∈ svs)
    → Γ
      ⊢i ψ^{svar:0↦X}^[[evar:E↦p]] <--->
         ψ^{svar:0↦X}^[[evar:E↦q]] using gpi
∀ X0 : svar,
  X0 ∈ sls
  → X0
    ∉ free_svars ψ^{svar:0↦X} ∪ free_svars p
      ∪ free_svars q
        *
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := ~~
                 match
                   maximal_mu_depth_to sdepth E
                     ψ
                 with
                 | 0 => true
                 | S _ => false
                 end) gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls)
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls)
≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: ∀ X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := ~~ false)
  gpi
IH: fresh_svars sls
  (free_svars ψ^{svar:0↦X} ∪ free_svars p
   ∪ free_svars q)
→ length sls
  ≥ maximal_mu_depth_to sdepth E ψ^{svar:0↦X}
  → (∀ X : svar, X ∈ sls → X ∈ svs)
    → Γ
      ⊢i ψ^{svar:0↦X}^[[evar:E↦p]] <--->
         ψ^{svar:0↦X}^[[evar:E↦q]] using gpi
no_dups sls destruct Hsl1.
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := ~~
                 match
                   maximal_mu_depth_to sdepth E
                     ψ
                 with
                 | 0 => true
                 | S _ => false
                 end) gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
svar_duplicates0: no_dups (X :: sls)
all_svars_fresh0: ∀ X0 : svar,
  X0 ∈ X :: sls
  → X0
    ∉ free_svars ψ ∪ free_svars p
      ∪ free_svars q
Hsl2: S (length sls)
≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: ∀ X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := ~~ false)
  gpi
IH: fresh_svars sls
  (free_svars ψ^{svar:0↦X} ∪ free_svars p
   ∪ free_svars q)
→ length sls
  ≥ maximal_mu_depth_to sdepth E ψ^{svar:0↦X}
  → (∀ X : svar, X ∈ sls → X ∈ svs)
    → Γ
      ⊢i ψ^{svar:0↦X}^[[evar:E↦p]] <--->
         ψ^{svar:0↦X}^[[evar:E↦q]] using gpi
no_dups sls apply svar_duplicates0.
        *
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := ~~
                 match
                   maximal_mu_depth_to sdepth E
                     ψ
                 with
                 | 0 => true
                 | S _ => false
                 end) gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls)
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls)
≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: ∀ X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := ~~ false)
  gpi
IH: fresh_svars sls
  (free_svars ψ^{svar:0↦X} ∪ free_svars p
   ∪ free_svars q)
→ length sls
  ≥ maximal_mu_depth_to sdepth E ψ^{svar:0↦X}
  → (∀ X : svar, X ∈ sls → X ∈ svs)
    → Γ
      ⊢i ψ^{svar:0↦X}^[[evar:E↦p]] <--->
         ψ^{svar:0↦X}^[[evar:E↦q]] using gpi
∀ X0 : svar,
  X0 ∈ sls
  → X0
    ∉ free_svars ψ^{svar:0↦X} ∪ free_svars p
      ∪ free_svars q destruct Hsl1.
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := ~~
                 match
                   maximal_mu_depth_to sdepth E
                     ψ
                 with
                 | 0 => true
                 | S _ => false
                 end) gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
svar_duplicates0: no_dups (X :: sls)
all_svars_fresh0: ∀ X0 : svar,
  X0 ∈ X :: sls
  → X0
    ∉ free_svars ψ ∪ free_svars p
      ∪ free_svars q
Hsl2: S (length sls)
≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: ∀ X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := ~~ false)
  gpi
IH: fresh_svars sls
  (free_svars ψ^{svar:0↦X} ∪ free_svars p
   ∪ free_svars q)
→ length sls
  ≥ maximal_mu_depth_to sdepth E ψ^{svar:0↦X}
  → (∀ X : svar, X ∈ sls → X ∈ svs)
    → Γ
      ⊢i ψ^{svar:0↦X}^[[evar:E↦p]] <--->
         ψ^{svar:0↦X}^[[evar:E↦q]] using gpi
∀ X0 : svar,
  X0 ∈ sls
  → X0
    ∉ free_svars ψ^{svar:0↦X} ∪ free_svars p
      ∪ free_svars q intros.
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := ~~
                 match
                   maximal_mu_depth_to sdepth E
                     ψ
                 with
                 | 0 => true
                 | S _ => false
                 end) gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
svar_duplicates0: no_dups (X :: sls)
all_svars_fresh0: ∀ X0 : svar,
  X0 ∈ X :: sls
  → X0
    ∉ free_svars ψ ∪ free_svars p
      ∪ free_svars q
Hsl2: S (length sls)
≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: ∀ X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := ~~ false)
  gpi
IH: fresh_svars sls
  (free_svars ψ^{svar:0↦X} ∪ free_svars p
   ∪ free_svars q)
→ length sls
  ≥ maximal_mu_depth_to sdepth E ψ^{svar:0↦X}
  → (∀ X : svar, X ∈ sls → X ∈ svs)
    → Γ
      ⊢i ψ^{svar:0↦X}^[[evar:E↦p]] <--->
         ψ^{svar:0↦X}^[[evar:E↦q]] using gpi
X0: svar
H1: X0 ∈ sls
X0
∉ free_svars ψ^{svar:0↦X} ∪ free_svars p
  ∪ free_svars q
          pose proof (free_svars_svar_open ψ X 0).
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := ~~
                 match
                   maximal_mu_depth_to sdepth E
                     ψ
                 with
                 | 0 => true
                 | S _ => false
                 end) gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
svar_duplicates0: no_dups (X :: sls)
all_svars_fresh0: ∀ X0 : svar,
  X0 ∈ X :: sls
  → X0
    ∉ free_svars ψ ∪ free_svars p
      ∪ free_svars q
Hsl2: S (length sls)
≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: ∀ X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := ~~ false)
  gpi
IH: fresh_svars sls
  (free_svars ψ^{svar:0↦X} ∪ free_svars p
   ∪ free_svars q)
→ length sls
  ≥ maximal_mu_depth_to sdepth E ψ^{svar:0↦X}
  → (∀ X : svar, X ∈ sls → X ∈ svs)
    → Γ
      ⊢i ψ^{svar:0↦X}^[[evar:E↦p]] <--->
         ψ^{svar:0↦X}^[[evar:E↦q]] using gpi
X0: svar
H1: X0 ∈ sls
H2: free_svars ψ^{svar:0↦X} ⊆ {[X]} ∪ free_svars ψ
X0
∉ free_svars ψ^{svar:0↦X} ∪ free_svars p
  ∪ free_svars q
          specialize (all_svars_fresh0 X0 ltac:(now right)).
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := ~~
                 match
                   maximal_mu_depth_to sdepth E
                     ψ
                 with
                 | 0 => true
                 | S _ => false
                 end) gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
svar_duplicates0: no_dups (X :: sls)
X0: svar
all_svars_fresh0: X0
∉ free_svars ψ ∪ free_svars p
  ∪ free_svars q
Hsl2: S (length sls)
≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: ∀ X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := ~~ false)
  gpi
IH: fresh_svars sls
  (free_svars ψ^{svar:0↦X} ∪ free_svars p
   ∪ free_svars q)
→ length sls
  ≥ maximal_mu_depth_to sdepth E ψ^{svar:0↦X}
  → (∀ X : svar, X ∈ sls → X ∈ svs)
    → Γ
      ⊢i ψ^{svar:0↦X}^[[evar:E↦p]] <--->
         ψ^{svar:0↦X}^[[evar:E↦q]] using gpi
H1: X0 ∈ sls
H2: free_svars ψ^{svar:0↦X} ⊆ {[X]} ∪ free_svars ψ
X0
∉ free_svars ψ^{svar:0↦X} ∪ free_svars p
  ∪ free_svars q
          simpl in *.
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := ~~
                 match
                   maximal_mu_depth_to sdepth E
                     ψ
                 with
                 | 0 => true
                 | S _ => false
                 end) gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
svar_duplicates0: (X ∉ sls) ∧ no_dups sls
X0: svar
all_svars_fresh0: X0
∉ free_svars ψ ∪ free_svars p
  ∪ free_svars q
Hsl2: S (length sls)
≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: ∀ X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := true)
  gpi
IH: fresh_svars sls
  (free_svars ψ^{svar:0↦X} ∪ free_svars p
   ∪ free_svars q)
→ length sls
  ≥ maximal_mu_depth_to sdepth E ψ^{svar:0↦X}
  → (∀ X : svar, X ∈ sls → X ∈ svs)
    → Γ
      ⊢i ψ^{svar:0↦X}^[[evar:E↦p]] <--->
         ψ^{svar:0↦X}^[[evar:E↦q]] using gpi
H1: X0 ∈ sls
H2: free_svars ψ^{svar:0↦X} ⊆ {[X]} ∪ free_svars ψ
X0
∉ free_svars ψ^{svar:0↦X} ∪ free_svars p
  ∪ free_svars q destruct svar_duplicates0.
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := ~~
                 match
                   maximal_mu_depth_to sdepth E
                     ψ
                 with
                 | 0 => true
                 | S _ => false
                 end) gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
H3: X ∉ sls
H4: no_dups sls
X0: svar
all_svars_fresh0: X0
∉ free_svars ψ ∪ free_svars p
  ∪ free_svars q
Hsl2: S (length sls)
≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: ∀ X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := true)
  gpi
IH: fresh_svars sls
  (free_svars ψ^{svar:0↦X} ∪ free_svars p
   ∪ free_svars q)
→ length sls
  ≥ maximal_mu_depth_to sdepth E ψ^{svar:0↦X}
  → (∀ X : svar, X ∈ sls → X ∈ svs)
    → Γ
      ⊢i ψ^{svar:0↦X}^[[evar:E↦p]] <--->
         ψ^{svar:0↦X}^[[evar:E↦q]] using gpi
H1: X0 ∈ sls
H2: free_svars ψ^{svar:0↦X} ⊆ {[X]} ∪ free_svars ψ
X0
∉ free_svars ψ^{svar:0↦X} ∪ free_svars p
  ∪ free_svars q
          clear -H3 H2 H1 all_svars_fresh0.
Σ: Signature
p, q, ψ: Pattern
X: svar
sls: list svar
H3: X ∉ sls
X0: svar
all_svars_fresh0: X0
∉ free_svars ψ ∪ free_svars p
  ∪ free_svars q
H1: X0 ∈ sls
H2: free_svars ψ^{svar:0↦X} ⊆ {[X]} ∪ free_svars ψ
X0
∉ free_svars ψ^{svar:0↦X} ∪ free_svars p
  ∪ free_svars q set_solver.
      }
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := ~~
                 match
                   maximal_mu_depth_to sdepth E
                     ψ
                 with
                 | 0 => true
                 | S _ => false
                 end) gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls)
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls)
≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: ∀ X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := ~~ false)
  gpi
IH: fresh_svars sls
  (free_svars ψ^{svar:0↦X} ∪ free_svars p
   ∪ free_svars q)
→ length sls
  ≥ maximal_mu_depth_to sdepth E ψ^{svar:0↦X}
  → (∀ X : svar, X ∈ sls → X ∈ svs)
    → Γ
      ⊢i ψ^{svar:0↦X}^[[evar:E↦p]] <--->
         ψ^{svar:0↦X}^[[evar:E↦q]] using gpi
length sls ≥ maximal_mu_depth_to sdepth E ψ^{svar:0↦X}
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := ~~
                 match
                   maximal_mu_depth_to sdepth E
                     ψ
                 with
                 | 0 => true
                 | S _ => false
                 end) gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls)
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls)
≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: ∀ X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := ~~ false)
  gpi
IH: fresh_svars sls
  (free_svars ψ^{svar:0↦X} ∪ free_svars p
   ∪ free_svars q)
→ length sls
  ≥ maximal_mu_depth_to sdepth E ψ^{svar:0↦X}
  → (∀ X : svar, X ∈ sls → X ∈ svs)
    → Γ
      ⊢i ψ^{svar:0↦X}^[[evar:E↦p]] <--->
         ψ^{svar:0↦X}^[[evar:E↦q]] using gpi
∀ X : svar, X ∈ sls → X ∈ svs
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := ~~
                 match
                   maximal_mu_depth_to sdepth E
                     ψ
                 with
                 | 0 => true
                 | S _ => false
                 end) gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls)
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls)
≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: ∀ X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := ~~ false)
  gpi
IH: Γ
⊢i ψ^{svar:0↦X}^[[evar:E↦p]] <--->
   ψ^{svar:0↦X}^[[evar:E↦q]] using gpi
Γ ⊢i (mu , ψ^[[evar:E↦p]]) <---> (mu , ψ^[[evar:E↦q]])
using gpi
      {
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := ~~
                 match
                   maximal_mu_depth_to sdepth E
                     ψ
                 with
                 | 0 => true
                 | S _ => false
                 end) gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls)
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls)
≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: ∀ X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := ~~ false)
  gpi
IH: fresh_svars sls
  (free_svars ψ^{svar:0↦X} ∪ free_svars p
   ∪ free_svars q)
→ length sls
  ≥ maximal_mu_depth_to sdepth E ψ^{svar:0↦X}
  → (∀ X : svar, X ∈ sls → X ∈ svs)
    → Γ
      ⊢i ψ^{svar:0↦X}^[[evar:E↦p]] <--->
         ψ^{svar:0↦X}^[[evar:E↦q]] using gpi
length sls ≥ maximal_mu_depth_to sdepth E ψ^{svar:0↦X}
        rewrite svar_open_mu_depth.
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := ~~
                 match
                   maximal_mu_depth_to sdepth E
                     ψ
                 with
                 | 0 => true
                 | S _ => false
                 end) gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls)
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls)
≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: ∀ X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := ~~ false)
  gpi
IH: fresh_svars sls
  (free_svars ψ^{svar:0↦X} ∪ free_svars p
   ∪ free_svars q)
→ length sls
  ≥ maximal_mu_depth_to sdepth E ψ^{svar:0↦X}
  → (∀ X : svar, X ∈ sls → X ∈ svs)
    → Γ
      ⊢i ψ^{svar:0↦X}^[[evar:E↦p]] <--->
         ψ^{svar:0↦X}^[[evar:E↦q]] using gpi
length sls ≥ maximal_mu_depth_to sdepth E ψ
        rewrite maximal_mu_depth_to_S in Hsl2.
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := ~~
                 match
                   maximal_mu_depth_to sdepth E
                     ψ
                 with
                 | 0 => true
                 | S _ => false
                 end) gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls)
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl3: ∀ X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := ~~ false)
  gpi
IH: fresh_svars sls
  (free_svars ψ^{svar:0↦X} ∪ free_svars p
   ∪ free_svars q)
→ length sls
  ≥ maximal_mu_depth_to sdepth E ψ^{svar:0↦X}
  → (∀ X : svar, X ∈ sls → X ∈ svs)
    → Γ
      ⊢i ψ^{svar:0↦X}^[[evar:E↦p]] <--->
         ψ^{svar:0↦X}^[[evar:E↦q]] using gpi
E ∈ free_evars ψ
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := ~~
                 match
                   maximal_mu_depth_to sdepth E
                     ψ
                 with
                 | 0 => true
                 | S _ => false
                 end) gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls)
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl3: ∀ X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := ~~ false)
  gpi
IH: fresh_svars sls
  (free_svars ψ^{svar:0↦X} ∪ free_svars p
   ∪ free_svars q)
→ length sls
  ≥ maximal_mu_depth_to sdepth E ψ^{svar:0↦X}
  → (∀ X : svar, X ∈ sls → X ∈ svs)
    → Γ
      ⊢i ψ^{svar:0↦X}^[[evar:E↦p]] <--->
         ψ^{svar:0↦X}^[[evar:E↦q]] using gpi
Hsl2: S (length sls)
≥ S (maximal_mu_depth_to sdepth E ψ)
length sls ≥ maximal_mu_depth_to sdepth E ψ assumption.
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := ~~
                 match
                   maximal_mu_depth_to sdepth E
                     ψ
                 with
                 | 0 => true
                 | S _ => false
                 end) gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls)
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl3: ∀ X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := ~~ false)
  gpi
IH: fresh_svars sls
  (free_svars ψ^{svar:0↦X} ∪ free_svars p
   ∪ free_svars q)
→ length sls
  ≥ maximal_mu_depth_to sdepth E ψ^{svar:0↦X}
  → (∀ X : svar, X ∈ sls → X ∈ svs)
    → Γ
      ⊢i ψ^{svar:0↦X}^[[evar:E↦p]] <--->
         ψ^{svar:0↦X}^[[evar:E↦q]] using gpi
Hsl2: S (length sls)
≥ S (maximal_mu_depth_to sdepth E ψ)
length sls ≥ maximal_mu_depth_to sdepth E ψ lia.
      }
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := ~~
                 match
                   maximal_mu_depth_to sdepth E
                     ψ
                 with
                 | 0 => true
                 | S _ => false
                 end) gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls)
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls)
≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: ∀ X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := ~~ false)
  gpi
IH: fresh_svars sls
  (free_svars ψ^{svar:0↦X} ∪ free_svars p
   ∪ free_svars q)
→ length sls
  ≥ maximal_mu_depth_to sdepth E ψ^{svar:0↦X}
  → (∀ X : svar, X ∈ sls → X ∈ svs)
    → Γ
      ⊢i ψ^{svar:0↦X}^[[evar:E↦p]] <--->
         ψ^{svar:0↦X}^[[evar:E↦q]] using gpi
∀ X : svar, X ∈ sls → X ∈ svs
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := ~~
                 match
                   maximal_mu_depth_to sdepth E
                     ψ
                 with
                 | 0 => true
                 | S _ => false
                 end) gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls)
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls)
≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: ∀ X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := ~~ false)
  gpi
IH: Γ
⊢i ψ^{svar:0↦X}^[[evar:E↦p]] <--->
   ψ^{svar:0↦X}^[[evar:E↦q]] using gpi
Γ ⊢i (mu , ψ^[[evar:E↦p]]) <---> (mu , ψ^[[evar:E↦q]])
using gpi
      {
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := ~~
                 match
                   maximal_mu_depth_to sdepth E
                     ψ
                 with
                 | 0 => true
                 | S _ => false
                 end) gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls)
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls)
≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: ∀ X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := ~~ false)
  gpi
IH: fresh_svars sls
  (free_svars ψ^{svar:0↦X} ∪ free_svars p
   ∪ free_svars q)
→ length sls
  ≥ maximal_mu_depth_to sdepth E ψ^{svar:0↦X}
  → (∀ X : svar, X ∈ sls → X ∈ svs)
    → Γ
      ⊢i ψ^{svar:0↦X}^[[evar:E↦p]] <--->
         ψ^{svar:0↦X}^[[evar:E↦q]] using gpi
∀ X : svar, X ∈ sls → X ∈ svs
        intros.
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := ~~
                 match
                   maximal_mu_depth_to sdepth E
                     ψ
                 with
                 | 0 => true
                 | S _ => false
                 end) gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls)
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls)
≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: ∀ X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := ~~ false)
  gpi
IH: fresh_svars sls
  (free_svars ψ^{svar:0↦X} ∪ free_svars p
   ∪ free_svars q)
→ length sls
  ≥ maximal_mu_depth_to sdepth E ψ^{svar:0↦X}
  → (∀ X : svar, X ∈ sls → X ∈ svs)
    → Γ
      ⊢i ψ^{svar:0↦X}^[[evar:E↦p]] <--->
         ψ^{svar:0↦X}^[[evar:E↦q]] using gpi
X0: svar
H1: X0 ∈ sls
X0 ∈ svs apply Hsl3.
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := ~~
                 match
                   maximal_mu_depth_to sdepth E
                     ψ
                 with
                 | 0 => true
                 | S _ => false
                 end) gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls)
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls)
≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: ∀ X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := ~~ false)
  gpi
IH: fresh_svars sls
  (free_svars ψ^{svar:0↦X} ∪ free_svars p
   ∪ free_svars q)
→ length sls
  ≥ maximal_mu_depth_to sdepth E ψ^{svar:0↦X}
  → (∀ X : svar, X ∈ sls → X ∈ svs)
    → Γ
      ⊢i ψ^{svar:0↦X}^[[evar:E↦p]] <--->
         ψ^{svar:0↦X}^[[evar:E↦q]] using gpi
X0: svar
H1: X0 ∈ sls
X0 ∈ X :: sls now right. 
      }
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := ~~
                 match
                   maximal_mu_depth_to sdepth E
                     ψ
                 with
                 | 0 => true
                 | S _ => false
                 end) gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls)
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls)
≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: ∀ X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := ~~ false)
  gpi
IH: Γ
⊢i ψ^{svar:0↦X}^[[evar:E↦p]] <--->
   ψ^{svar:0↦X}^[[evar:E↦q]] using gpi
Γ ⊢i (mu , ψ^[[evar:E↦p]]) <---> (mu , ψ^[[evar:E↦q]])
using gpi

      unfold svar_open in IH.
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := ~~
                 match
                   maximal_mu_depth_to sdepth E
                     ψ
                 with
                 | 0 => true
                 | S _ => false
                 end) gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls)
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls)
≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: ∀ X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := ~~ false)
  gpi
IH: Γ
⊢i ψ^[svar:0↦patt_free_svar X]^[[evar:E↦p]] <--->
   ψ^[svar:0↦patt_free_svar X]^[[evar:E↦q]]
using gpi
Γ ⊢i (mu , ψ^[[evar:E↦p]]) <---> (mu , ψ^[[evar:E↦q]])
using gpi
      rewrite free_evar_subst_bsvar_subst in IH.
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := ~~
                 match
                   maximal_mu_depth_to sdepth E
                     ψ
                 with
                 | 0 => true
                 | S _ => false
                 end) gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls)
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls)
≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: ∀ X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := ~~ false)
  gpi
well_formed_closed_mu_aux p 0
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := ~~
                 match
                   maximal_mu_depth_to sdepth E
                     ψ
                 with
                 | 0 => true
                 | S _ => false
                 end) gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls)
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls)
≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: ∀ X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := ~~ false)
  gpi
evar_is_fresh_in E (patt_free_svar X)
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := ~~
                 match
                   maximal_mu_depth_to sdepth E
                     ψ
                 with
                 | 0 => true
                 | S _ => false
                 end) gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls)
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls)
≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: ∀ X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := ~~ false)
  gpi
IH: Γ
⊢i ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] <--->
   ψ^[svar:0↦patt_free_svar X]^[[evar:E↦q]]
using gpi
Γ ⊢i (mu , ψ^[[evar:E↦p]]) <---> (mu , ψ^[[evar:E↦q]])
using gpi
      1: wf_auto2.
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := ~~
                 match
                   maximal_mu_depth_to sdepth E
                     ψ
                 with
                 | 0 => true
                 | S _ => false
                 end) gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls)
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls)
≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: ∀ X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := ~~ false)
  gpi
evar_is_fresh_in E (patt_free_svar X)
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := ~~
                 match
                   maximal_mu_depth_to sdepth E
                     ψ
                 with
                 | 0 => true
                 | S _ => false
                 end) gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls)
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls)
≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: ∀ X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := ~~ false)
  gpi
IH: Γ
⊢i ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] <--->
   ψ^[svar:0↦patt_free_svar X]^[[evar:E↦q]]
using gpi
Γ ⊢i (mu , ψ^[[evar:E↦p]]) <---> (mu , ψ^[[evar:E↦q]])
using gpi
      1: {
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := ~~
                 match
                   maximal_mu_depth_to sdepth E
                     ψ
                 with
                 | 0 => true
                 | S _ => false
                 end) gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls)
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls)
≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: ∀ X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := ~~ false)
  gpi
evar_is_fresh_in E (patt_free_svar X) unfold evar_is_fresh_in.
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := ~~
                 match
                   maximal_mu_depth_to sdepth E
                     ψ
                 with
                 | 0 => true
                 | S _ => false
                 end) gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls)
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls)
≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: ∀ X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := ~~ false)
  gpi
E ∉ free_evars (patt_free_svar X) set_solver. }
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := ~~
                 match
                   maximal_mu_depth_to sdepth E
                     ψ
                 with
                 | 0 => true
                 | S _ => false
                 end) gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls)
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls)
≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: ∀ X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := ~~ false)
  gpi
IH: Γ
⊢i ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] <--->
   ψ^[svar:0↦patt_free_svar X]^[[evar:E↦q]]
using gpi
Γ ⊢i (mu , ψ^[[evar:E↦p]]) <---> (mu , ψ^[[evar:E↦q]])
using gpi
      rewrite free_evar_subst_bsvar_subst in IH.
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := ~~
                 match
                   maximal_mu_depth_to sdepth E
                     ψ
                 with
                 | 0 => true
                 | S _ => false
                 end) gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls)
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls)
≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: ∀ X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := ~~ false)
  gpi
well_formed_closed_mu_aux q 0
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := ~~
                 match
                   maximal_mu_depth_to sdepth E
                     ψ
                 with
                 | 0 => true
                 | S _ => false
                 end) gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls)
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls)
≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: ∀ X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := ~~ false)
  gpi
evar_is_fresh_in E (patt_free_svar X)
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := ~~
                 match
                   maximal_mu_depth_to sdepth E
                     ψ
                 with
                 | 0 => true
                 | S _ => false
                 end) gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls)
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls)
≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: ∀ X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := ~~ false)
  gpi
IH: Γ
⊢i ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] <--->
   ψ^[[evar:E↦q]]^[svar:0↦
   patt_free_svar X] using gpi
Γ ⊢i (mu , ψ^[[evar:E↦p]]) <---> (mu , ψ^[[evar:E↦q]])
using gpi
      1: wf_auto2.
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := ~~
                 match
                   maximal_mu_depth_to sdepth E
                     ψ
                 with
                 | 0 => true
                 | S _ => false
                 end) gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls)
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls)
≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: ∀ X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := ~~ false)
  gpi
evar_is_fresh_in E (patt_free_svar X)
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := ~~
                 match
                   maximal_mu_depth_to sdepth E
                     ψ
                 with
                 | 0 => true
                 | S _ => false
                 end) gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls)
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls)
≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: ∀ X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := ~~ false)
  gpi
IH: Γ
⊢i ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] <--->
   ψ^[[evar:E↦q]]^[svar:0↦
   patt_free_svar X] using gpi
Γ ⊢i (mu , ψ^[[evar:E↦p]]) <---> (mu , ψ^[[evar:E↦q]])
using gpi
      1: {
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := ~~
                 match
                   maximal_mu_depth_to sdepth E
                     ψ
                 with
                 | 0 => true
                 | S _ => false
                 end) gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls)
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls)
≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: ∀ X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := ~~ false)
  gpi
evar_is_fresh_in E (patt_free_svar X) unfold evar_is_fresh_in.
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := ~~
                 match
                   maximal_mu_depth_to sdepth E
                     ψ
                 with
                 | 0 => true
                 | S _ => false
                 end) gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls)
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls)
≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: ∀ X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := ~~ false)
  gpi
E ∉ free_evars (patt_free_svar X) set_solver. }
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := ~~
                 match
                   maximal_mu_depth_to sdepth E
                     ψ
                 with
                 | 0 => true
                 | S _ => false
                 end) gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls)
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls)
≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: ∀ X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := ~~ false)
  gpi
IH: Γ
⊢i ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] <--->
   ψ^[[evar:E↦q]]^[svar:0↦
   patt_free_svar X] using gpi
Γ ⊢i (mu , ψ^[[evar:E↦p]]) <---> (mu , ψ^[[evar:E↦q]])
using gpi

      unshelve (epose proof (IH1 := pf_iff_proj1 _ _ _ _ _ _ IH)).
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := ~~
                 match
                   maximal_mu_depth_to sdepth E
                     ψ
                 with
                 | 0 => true
                 | S _ => false
                 end) gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls)
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls)
≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: ∀ X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := ~~ false)
  gpi
IH: Γ
⊢i ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] <--->
   ψ^[[evar:E↦q]]^[svar:0↦
   patt_free_svar X] using gpi
well_formed ψ^[[evar:E↦p]]^[svar:0↦patt_free_svar X]
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := ~~
                 match
                   maximal_mu_depth_to sdepth E
                     ψ
                 with
                 | 0 => true
                 | S _ => false
                 end) gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls)
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls)
≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: ∀ X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := ~~ false)
  gpi
IH: Γ
⊢i ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] <--->
   ψ^[[evar:E↦q]]^[svar:0↦
   patt_free_svar X] using gpi
well_formed ψ^[[evar:E↦q]]^[svar:0↦patt_free_svar X]
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := ~~
                 match
                   maximal_mu_depth_to sdepth E
                     ψ
                 with
                 | 0 => true
                 | S _ => false
                 end) gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls)
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls)
≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: ∀ X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := ~~ false)
  gpi
IH: Γ
⊢i ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] <--->
   ψ^[[evar:E↦q]]^[svar:0↦
   patt_free_svar X] using gpi
IH1: Γ
⊢i ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] --->
   ψ^[[evar:E↦q]]^[svar:0↦
   patt_free_svar X] using gpi
Γ ⊢i (mu , ψ^[[evar:E↦p]]) <---> (mu , ψ^[[evar:E↦q]])
using gpi
      {
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := ~~
                 match
                   maximal_mu_depth_to sdepth E
                     ψ
                 with
                 | 0 => true
                 | S _ => false
                 end) gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls)
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls)
≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: ∀ X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := ~~ false)
  gpi
IH: Γ
⊢i ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] <--->
   ψ^[[evar:E↦q]]^[svar:0↦
   patt_free_svar X] using gpi
well_formed ψ^[[evar:E↦p]]^[svar:0↦patt_free_svar X] clear -wfψ wfp.
Σ: Signature
p: Pattern
wfp: well_formed p
E: evar
ψ: Pattern
wfψ: well_formed (mu , ψ)
X: svar
well_formed ψ^[[evar:E↦p]]^[svar:0↦patt_free_svar X] abstract (wf_auto2). }
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := ~~
                 match
                   maximal_mu_depth_to sdepth E
                     ψ
                 with
                 | 0 => true
                 | S _ => false
                 end) gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls)
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls)
≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: ∀ X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := ~~ false)
  gpi
IH: Γ
⊢i ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] <--->
   ψ^[[evar:E↦q]]^[svar:0↦
   patt_free_svar X] using gpi
well_formed ψ^[[evar:E↦q]]^[svar:0↦patt_free_svar X]
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := ~~
                 match
                   maximal_mu_depth_to sdepth E
                     ψ
                 with
                 | 0 => true
                 | S _ => false
                 end) gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls)
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls)
≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: ∀ X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := ~~ false)
  gpi
IH: Γ
⊢i ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] <--->
   ψ^[[evar:E↦q]]^[svar:0↦
   patt_free_svar X] using gpi
IH1: Γ
⊢i ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] --->
   ψ^[[evar:E↦q]]^[svar:0↦
   patt_free_svar X] using gpi
Γ ⊢i (mu , ψ^[[evar:E↦p]]) <---> (mu , ψ^[[evar:E↦q]])
using gpi
      {
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := ~~
                 match
                   maximal_mu_depth_to sdepth E
                     ψ
                 with
                 | 0 => true
                 | S _ => false
                 end) gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls)
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls)
≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: ∀ X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := ~~ false)
  gpi
IH: Γ
⊢i ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] <--->
   ψ^[[evar:E↦q]]^[svar:0↦
   patt_free_svar X] using gpi
well_formed ψ^[[evar:E↦q]]^[svar:0↦patt_free_svar X] clear -wfψ wfq.
Σ: Signature
q: Pattern
wfq: well_formed q
E: evar
ψ: Pattern
wfψ: well_formed (mu , ψ)
X: svar
well_formed ψ^[[evar:E↦q]]^[svar:0↦patt_free_svar X] abstract (wf_auto2). }
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := ~~
                 match
                   maximal_mu_depth_to sdepth E
                     ψ
                 with
                 | 0 => true
                 | S _ => false
                 end) gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls)
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls)
≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: ∀ X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := ~~ false)
  gpi
IH: Γ
⊢i ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] <--->
   ψ^[[evar:E↦q]]^[svar:0↦
   patt_free_svar X] using gpi
IH1: Γ
⊢i ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] --->
   ψ^[[evar:E↦q]]^[svar:0↦
   patt_free_svar X] using gpi
Γ ⊢i (mu , ψ^[[evar:E↦p]]) <---> (mu , ψ^[[evar:E↦q]])
using gpi
      unshelve (epose proof (IH2 := pf_iff_proj2 _ _ _ _ _ _ IH)).
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := ~~
                 match
                   maximal_mu_depth_to sdepth E
                     ψ
                 with
                 | 0 => true
                 | S _ => false
                 end) gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls)
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls)
≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: ∀ X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := ~~ false)
  gpi
IH: Γ
⊢i ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] <--->
   ψ^[[evar:E↦q]]^[svar:0↦
   patt_free_svar X] using gpi
IH1: Γ
⊢i ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] --->
   ψ^[[evar:E↦q]]^[svar:0↦
   patt_free_svar X] using gpi
well_formed ψ^[[evar:E↦p]]^[svar:0↦patt_free_svar X]
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := ~~
                 match
                   maximal_mu_depth_to sdepth E
                     ψ
                 with
                 | 0 => true
                 | S _ => false
                 end) gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls)
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls)
≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: ∀ X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := ~~ false)
  gpi
IH: Γ
⊢i ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] <--->
   ψ^[[evar:E↦q]]^[svar:0↦
   patt_free_svar X] using gpi
IH1: Γ
⊢i ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] --->
   ψ^[[evar:E↦q]]^[svar:0↦
   patt_free_svar X] using gpi
well_formed ψ^[[evar:E↦q]]^[svar:0↦patt_free_svar X]
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := ~~
                 match
                   maximal_mu_depth_to sdepth E
                     ψ
                 with
                 | 0 => true
                 | S _ => false
                 end) gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls)
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls)
≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: ∀ X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := ~~ false)
  gpi
IH: Γ
⊢i ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] <--->
   ψ^[[evar:E↦q]]^[svar:0↦
   patt_free_svar X] using gpi
IH1: Γ
⊢i ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] --->
   ψ^[[evar:E↦q]]^[svar:0↦
   patt_free_svar X] using gpi
IH2: Γ
⊢i ψ^[[evar:E↦q]]^[svar:0↦
   patt_free_svar X] --->
   ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] using gpi
Γ ⊢i (mu , ψ^[[evar:E↦p]]) <---> (mu , ψ^[[evar:E↦q]])
using gpi
      {
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := ~~
                 match
                   maximal_mu_depth_to sdepth E
                     ψ
                 with
                 | 0 => true
                 | S _ => false
                 end) gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls)
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls)
≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: ∀ X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := ~~ false)
  gpi
IH: Γ
⊢i ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] <--->
   ψ^[[evar:E↦q]]^[svar:0↦
   patt_free_svar X] using gpi
IH1: Γ
⊢i ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] --->
   ψ^[[evar:E↦q]]^[svar:0↦
   patt_free_svar X] using gpi
well_formed ψ^[[evar:E↦p]]^[svar:0↦patt_free_svar X] clear -wfψ wfp.
Σ: Signature
p: Pattern
wfp: well_formed p
E: evar
ψ: Pattern
wfψ: well_formed (mu , ψ)
X: svar
well_formed ψ^[[evar:E↦p]]^[svar:0↦patt_free_svar X] abstract (wf_auto2). }
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := ~~
                 match
                   maximal_mu_depth_to sdepth E
                     ψ
                 with
                 | 0 => true
                 | S _ => false
                 end) gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls)
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls)
≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: ∀ X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := ~~ false)
  gpi
IH: Γ
⊢i ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] <--->
   ψ^[[evar:E↦q]]^[svar:0↦
   patt_free_svar X] using gpi
IH1: Γ
⊢i ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] --->
   ψ^[[evar:E↦q]]^[svar:0↦
   patt_free_svar X] using gpi
well_formed ψ^[[evar:E↦q]]^[svar:0↦patt_free_svar X]
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := ~~
                 match
                   maximal_mu_depth_to sdepth E
                     ψ
                 with
                 | 0 => true
                 | S _ => false
                 end) gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls)
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls)
≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: ∀ X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := ~~ false)
  gpi
IH: Γ
⊢i ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] <--->
   ψ^[[evar:E↦q]]^[svar:0↦
   patt_free_svar X] using gpi
IH1: Γ
⊢i ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] --->
   ψ^[[evar:E↦q]]^[svar:0↦
   patt_free_svar X] using gpi
IH2: Γ
⊢i ψ^[[evar:E↦q]]^[svar:0↦
   patt_free_svar X] --->
   ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] using gpi
Γ ⊢i (mu , ψ^[[evar:E↦p]]) <---> (mu , ψ^[[evar:E↦q]])
using gpi
      {
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := ~~
                 match
                   maximal_mu_depth_to sdepth E
                     ψ
                 with
                 | 0 => true
                 | S _ => false
                 end) gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls)
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls)
≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: ∀ X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := ~~ false)
  gpi
IH: Γ
⊢i ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] <--->
   ψ^[[evar:E↦q]]^[svar:0↦
   patt_free_svar X] using gpi
IH1: Γ
⊢i ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] --->
   ψ^[[evar:E↦q]]^[svar:0↦
   patt_free_svar X] using gpi
well_formed ψ^[[evar:E↦q]]^[svar:0↦patt_free_svar X] clear -wfψ wfq.
Σ: Signature
q: Pattern
wfq: well_formed q
E: evar
ψ: Pattern
wfψ: well_formed (mu , ψ)
X: svar
well_formed ψ^[[evar:E↦q]]^[svar:0↦patt_free_svar X] abstract (wf_auto2). }
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := ~~
                 match
                   maximal_mu_depth_to sdepth E
                     ψ
                 with
                 | 0 => true
                 | S _ => false
                 end) gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls)
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls)
≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: ∀ X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := ~~ false)
  gpi
IH: Γ
⊢i ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] <--->
   ψ^[[evar:E↦q]]^[svar:0↦
   patt_free_svar X] using gpi
IH1: Γ
⊢i ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] --->
   ψ^[[evar:E↦q]]^[svar:0↦
   patt_free_svar X] using gpi
IH2: Γ
⊢i ψ^[[evar:E↦q]]^[svar:0↦
   patt_free_svar X] --->
   ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] using gpi
Γ ⊢i (mu , ψ^[[evar:E↦p]]) <---> (mu , ψ^[[evar:E↦q]])
using gpi

      rewrite <- (svar_quantify_svar_open X 0 (ψ^[[evar:E↦p]])).
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := ~~
                 match
                   maximal_mu_depth_to sdepth E
                     ψ
                 with
                 | 0 => true
                 | S _ => false
                 end) gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls)
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls)
≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: ∀ X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := ~~ false)
  gpi
IH: Γ
⊢i ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] <--->
   ψ^[[evar:E↦q]]^[svar:0↦
   patt_free_svar X] using gpi
IH1: Γ
⊢i ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] --->
   ψ^[[evar:E↦q]]^[svar:0↦
   patt_free_svar X] using gpi
IH2: Γ
⊢i ψ^[[evar:E↦q]]^[svar:0↦
   patt_free_svar X] --->
   ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] using gpi
Γ
⊢i (mu , ψ^[[evar:E↦p]]^{svar:0↦X}^{{svar:X↦0}}) <--->
   (mu , ψ^[[evar:E↦q]]) using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := ~~
                 match
                   maximal_mu_depth_to sdepth E
                     ψ
                 with
                 | 0 => true
                 | S _ => false
                 end) gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls)
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls)
≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: ∀ X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := ~~ false)
  gpi
IH: Γ
⊢i ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] <--->
   ψ^[[evar:E↦q]]^[svar:0↦
   patt_free_svar X] using gpi
IH1: Γ
⊢i ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] --->
   ψ^[[evar:E↦q]]^[svar:0↦
   patt_free_svar X] using gpi
IH2: Γ
⊢i ψ^[[evar:E↦q]]^[svar:0↦
   patt_free_svar X] --->
   ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] using gpi
X ∉ free_svars ψ^[[evar:E↦p]]
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := ~~
                 match
                   maximal_mu_depth_to sdepth E
                     ψ
                 with
                 | 0 => true
                 | S _ => false
                 end) gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls)
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls)
≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: ∀ X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := ~~ false)
  gpi
IH: Γ
⊢i ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] <--->
   ψ^[[evar:E↦q]]^[svar:0↦
   patt_free_svar X] using gpi
IH1: Γ
⊢i ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] --->
   ψ^[[evar:E↦q]]^[svar:0↦
   patt_free_svar X] using gpi
IH2: Γ
⊢i ψ^[[evar:E↦q]]^[svar:0↦
   patt_free_svar X] --->
   ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] using gpi
well_formed_closed_mu_aux ψ^[[evar:E↦p]] 1
      rewrite <- (svar_quantify_svar_open X 0 (ψ^[[evar:E↦q]])).
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := ~~
                 match
                   maximal_mu_depth_to sdepth E
                     ψ
                 with
                 | 0 => true
                 | S _ => false
                 end) gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls)
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls)
≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: ∀ X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := ~~ false)
  gpi
IH: Γ
⊢i ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] <--->
   ψ^[[evar:E↦q]]^[svar:0↦
   patt_free_svar X] using gpi
IH1: Γ
⊢i ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] --->
   ψ^[[evar:E↦q]]^[svar:0↦
   patt_free_svar X] using gpi
IH2: Γ
⊢i ψ^[[evar:E↦q]]^[svar:0↦
   patt_free_svar X] --->
   ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] using gpi
Γ
⊢i (mu , ψ^[[evar:E↦p]]^{svar:0↦X}^{{svar:X↦0}}) <--->
   (mu , ψ^[[evar:E↦q]]^{svar:0↦X}^{{svar:X↦0}})
using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := ~~
                 match
                   maximal_mu_depth_to sdepth E
                     ψ
                 with
                 | 0 => true
                 | S _ => false
                 end) gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls)
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls)
≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: ∀ X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := ~~ false)
  gpi
IH: Γ
⊢i ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] <--->
   ψ^[[evar:E↦q]]^[svar:0↦
   patt_free_svar X] using gpi
IH1: Γ
⊢i ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] --->
   ψ^[[evar:E↦q]]^[svar:0↦
   patt_free_svar X] using gpi
IH2: Γ
⊢i ψ^[[evar:E↦q]]^[svar:0↦
   patt_free_svar X] --->
   ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] using gpi
X ∉ free_svars ψ^[[evar:E↦q]]
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := ~~
                 match
                   maximal_mu_depth_to sdepth E
                     ψ
                 with
                 | 0 => true
                 | S _ => false
                 end) gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls)
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls)
≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: ∀ X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := ~~ false)
  gpi
IH: Γ
⊢i ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] <--->
   ψ^[[evar:E↦q]]^[svar:0↦
   patt_free_svar X] using gpi
IH1: Γ
⊢i ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] --->
   ψ^[[evar:E↦q]]^[svar:0↦
   patt_free_svar X] using gpi
IH2: Γ
⊢i ψ^[[evar:E↦q]]^[svar:0↦
   patt_free_svar X] --->
   ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] using gpi
well_formed_closed_mu_aux ψ^[[evar:E↦q]] 1
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := ~~
                 match
                   maximal_mu_depth_to sdepth E
                     ψ
                 with
                 | 0 => true
                 | S _ => false
                 end) gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls)
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls)
≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: ∀ X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := ~~ false)
  gpi
IH: Γ
⊢i ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] <--->
   ψ^[[evar:E↦q]]^[svar:0↦
   patt_free_svar X] using gpi
IH1: Γ
⊢i ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] --->
   ψ^[[evar:E↦q]]^[svar:0↦
   patt_free_svar X] using gpi
IH2: Γ
⊢i ψ^[[evar:E↦q]]^[svar:0↦
   patt_free_svar X] --->
   ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] using gpi
X ∉ free_svars ψ^[[evar:E↦p]]
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := ~~
                 match
                   maximal_mu_depth_to sdepth E
                     ψ
                 with
                 | 0 => true
                 | S _ => false
                 end) gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls)
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls)
≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: ∀ X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := ~~ false)
  gpi
IH: Γ
⊢i ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] <--->
   ψ^[[evar:E↦q]]^[svar:0↦
   patt_free_svar X] using gpi
IH1: Γ
⊢i ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] --->
   ψ^[[evar:E↦q]]^[svar:0↦
   patt_free_svar X] using gpi
IH2: Γ
⊢i ψ^[[evar:E↦q]]^[svar:0↦
   patt_free_svar X] --->
   ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] using gpi
well_formed_closed_mu_aux ψ^[[evar:E↦p]] 1
      2: {
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := ~~
                 match
                   maximal_mu_depth_to sdepth E
                     ψ
                 with
                 | 0 => true
                 | S _ => false
                 end) gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls)
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls)
≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: ∀ X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := ~~ false)
  gpi
IH: Γ
⊢i ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] <--->
   ψ^[[evar:E↦q]]^[svar:0↦
   patt_free_svar X] using gpi
IH1: Γ
⊢i ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] --->
   ψ^[[evar:E↦q]]^[svar:0↦
   patt_free_svar X] using gpi
IH2: Γ
⊢i ψ^[[evar:E↦q]]^[svar:0↦
   patt_free_svar X] --->
   ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] using gpi
X ∉ free_svars ψ^[[evar:E↦q]]
        pose proof (free_svars_free_evar_subst ψ E q).
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := ~~
                 match
                   maximal_mu_depth_to sdepth E
                     ψ
                 with
                 | 0 => true
                 | S _ => false
                 end) gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls)
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls)
≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: ∀ X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := ~~ false)
  gpi
IH: Γ
⊢i ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] <--->
   ψ^[[evar:E↦q]]^[svar:0↦
   patt_free_svar X] using gpi
IH1: Γ
⊢i ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] --->
   ψ^[[evar:E↦q]]^[svar:0↦
   patt_free_svar X] using gpi
IH2: Γ
⊢i ψ^[[evar:E↦q]]^[svar:0↦
   patt_free_svar X] --->
   ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] using gpi
H1: free_svars ψ^[[evar:E↦q]]
⊆ free_svars ψ ∪ free_svars q
X ∉ free_svars ψ^[[evar:E↦q]]
        destruct Hsl1 as [_ ?].
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := ~~
                 match
                   maximal_mu_depth_to sdepth E
                     ψ
                 with
                 | 0 => true
                 | S _ => false
                 end) gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
all_svars_fresh0: ∀ X0 : svar,
  X0 ∈ X :: sls
  → X0
    ∉ free_svars ψ ∪ free_svars p
      ∪ free_svars q
Hsl2: S (length sls)
≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: ∀ X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := ~~ false)
  gpi
IH: Γ
⊢i ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] <--->
   ψ^[[evar:E↦q]]^[svar:0↦
   patt_free_svar X] using gpi
IH1: Γ
⊢i ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] --->
   ψ^[[evar:E↦q]]^[svar:0↦
   patt_free_svar X] using gpi
IH2: Γ
⊢i ψ^[[evar:E↦q]]^[svar:0↦
   patt_free_svar X] --->
   ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] using gpi
H1: free_svars ψ^[[evar:E↦q]]
⊆ free_svars ψ ∪ free_svars q
X ∉ free_svars ψ^[[evar:E↦q]] clear -all_svars_fresh0 H1.
Σ: Signature
p, q: Pattern
E: evar
ψ: Pattern
X: svar
sls: list svar
all_svars_fresh0: ∀ X0 : svar,
  X0 ∈ X :: sls
  → X0
    ∉ free_svars ψ ∪ free_svars p
      ∪ free_svars q
H1: free_svars ψ^[[evar:E↦q]]
⊆ free_svars ψ ∪ free_svars q
X ∉ free_svars ψ^[[evar:E↦q]]
        set_solver.
      }
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := ~~
                 match
                   maximal_mu_depth_to sdepth E
                     ψ
                 with
                 | 0 => true
                 | S _ => false
                 end) gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls)
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls)
≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: ∀ X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := ~~ false)
  gpi
IH: Γ
⊢i ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] <--->
   ψ^[[evar:E↦q]]^[svar:0↦
   patt_free_svar X] using gpi
IH1: Γ
⊢i ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] --->
   ψ^[[evar:E↦q]]^[svar:0↦
   patt_free_svar X] using gpi
IH2: Γ
⊢i ψ^[[evar:E↦q]]^[svar:0↦
   patt_free_svar X] --->
   ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] using gpi
Γ
⊢i (mu , ψ^[[evar:E↦p]]^{svar:0↦X}^{{svar:X↦0}}) <--->
   (mu , ψ^[[evar:E↦q]]^{svar:0↦X}^{{svar:X↦0}})
using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := ~~
                 match
                   maximal_mu_depth_to sdepth E
                     ψ
                 with
                 | 0 => true
                 | S _ => false
                 end) gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls)
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls)
≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: ∀ X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := ~~ false)
  gpi
IH: Γ
⊢i ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] <--->
   ψ^[[evar:E↦q]]^[svar:0↦
   patt_free_svar X] using gpi
IH1: Γ
⊢i ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] --->
   ψ^[[evar:E↦q]]^[svar:0↦
   patt_free_svar X] using gpi
IH2: Γ
⊢i ψ^[[evar:E↦q]]^[svar:0↦
   patt_free_svar X] --->
   ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] using gpi
well_formed_closed_mu_aux ψ^[[evar:E↦q]] 1
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := ~~
                 match
                   maximal_mu_depth_to sdepth E
                     ψ
                 with
                 | 0 => true
                 | S _ => false
                 end) gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls)
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls)
≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: ∀ X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := ~~ false)
  gpi
IH: Γ
⊢i ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] <--->
   ψ^[[evar:E↦q]]^[svar:0↦
   patt_free_svar X] using gpi
IH1: Γ
⊢i ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] --->
   ψ^[[evar:E↦q]]^[svar:0↦
   patt_free_svar X] using gpi
IH2: Γ
⊢i ψ^[[evar:E↦q]]^[svar:0↦
   patt_free_svar X] --->
   ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] using gpi
X ∉ free_svars ψ^[[evar:E↦p]]
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := ~~
                 match
                   maximal_mu_depth_to sdepth E
                     ψ
                 with
                 | 0 => true
                 | S _ => false
                 end) gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls)
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls)
≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: ∀ X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := ~~ false)
  gpi
IH: Γ
⊢i ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] <--->
   ψ^[[evar:E↦q]]^[svar:0↦
   patt_free_svar X] using gpi
IH1: Γ
⊢i ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] --->
   ψ^[[evar:E↦q]]^[svar:0↦
   patt_free_svar X] using gpi
IH2: Γ
⊢i ψ^[[evar:E↦q]]^[svar:0↦
   patt_free_svar X] --->
   ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] using gpi
well_formed_closed_mu_aux ψ^[[evar:E↦p]] 1
      3: {
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := ~~
                 match
                   maximal_mu_depth_to sdepth E
                     ψ
                 with
                 | 0 => true
                 | S _ => false
                 end) gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls)
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls)
≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: ∀ X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := ~~ false)
  gpi
IH: Γ
⊢i ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] <--->
   ψ^[[evar:E↦q]]^[svar:0↦
   patt_free_svar X] using gpi
IH1: Γ
⊢i ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] --->
   ψ^[[evar:E↦q]]^[svar:0↦
   patt_free_svar X] using gpi
IH2: Γ
⊢i ψ^[[evar:E↦q]]^[svar:0↦
   patt_free_svar X] --->
   ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] using gpi
X ∉ free_svars ψ^[[evar:E↦p]]
        pose proof (free_svars_free_evar_subst ψ E p).
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := ~~
                 match
                   maximal_mu_depth_to sdepth E
                     ψ
                 with
                 | 0 => true
                 | S _ => false
                 end) gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls)
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls)
≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: ∀ X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := ~~ false)
  gpi
IH: Γ
⊢i ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] <--->
   ψ^[[evar:E↦q]]^[svar:0↦
   patt_free_svar X] using gpi
IH1: Γ
⊢i ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] --->
   ψ^[[evar:E↦q]]^[svar:0↦
   patt_free_svar X] using gpi
IH2: Γ
⊢i ψ^[[evar:E↦q]]^[svar:0↦
   patt_free_svar X] --->
   ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] using gpi
H1: free_svars ψ^[[evar:E↦p]]
⊆ free_svars ψ ∪ free_svars p
X ∉ free_svars ψ^[[evar:E↦p]]
        destruct Hsl1 as [_ ?].
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := ~~
                 match
                   maximal_mu_depth_to sdepth E
                     ψ
                 with
                 | 0 => true
                 | S _ => false
                 end) gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
all_svars_fresh0: ∀ X0 : svar,
  X0 ∈ X :: sls
  → X0
    ∉ free_svars ψ ∪ free_svars p
      ∪ free_svars q
Hsl2: S (length sls)
≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: ∀ X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := ~~ false)
  gpi
IH: Γ
⊢i ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] <--->
   ψ^[[evar:E↦q]]^[svar:0↦
   patt_free_svar X] using gpi
IH1: Γ
⊢i ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] --->
   ψ^[[evar:E↦q]]^[svar:0↦
   patt_free_svar X] using gpi
IH2: Γ
⊢i ψ^[[evar:E↦q]]^[svar:0↦
   patt_free_svar X] --->
   ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] using gpi
H1: free_svars ψ^[[evar:E↦p]]
⊆ free_svars ψ ∪ free_svars p
X ∉ free_svars ψ^[[evar:E↦p]] clear -all_svars_fresh0 H1.
Σ: Signature
p, q: Pattern
E: evar
ψ: Pattern
X: svar
sls: list svar
all_svars_fresh0: ∀ X0 : svar,
  X0 ∈ X :: sls
  → X0
    ∉ free_svars ψ ∪ free_svars p
      ∪ free_svars q
H1: free_svars ψ^[[evar:E↦p]]
⊆ free_svars ψ ∪ free_svars p
X ∉ free_svars ψ^[[evar:E↦p]]
        set_solver.
      }
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := ~~
                 match
                   maximal_mu_depth_to sdepth E
                     ψ
                 with
                 | 0 => true
                 | S _ => false
                 end) gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls)
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls)
≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: ∀ X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := ~~ false)
  gpi
IH: Γ
⊢i ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] <--->
   ψ^[[evar:E↦q]]^[svar:0↦
   patt_free_svar X] using gpi
IH1: Γ
⊢i ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] --->
   ψ^[[evar:E↦q]]^[svar:0↦
   patt_free_svar X] using gpi
IH2: Γ
⊢i ψ^[[evar:E↦q]]^[svar:0↦
   patt_free_svar X] --->
   ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] using gpi
Γ
⊢i (mu , ψ^[[evar:E↦p]]^{svar:0↦X}^{{svar:X↦0}}) <--->
   (mu , ψ^[[evar:E↦q]]^{svar:0↦X}^{{svar:X↦0}})
using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := ~~
                 match
                   maximal_mu_depth_to sdepth E
                     ψ
                 with
                 | 0 => true
                 | S _ => false
                 end) gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls)
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls)
≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: ∀ X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := ~~ false)
  gpi
IH: Γ
⊢i ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] <--->
   ψ^[[evar:E↦q]]^[svar:0↦
   patt_free_svar X] using gpi
IH1: Γ
⊢i ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] --->
   ψ^[[evar:E↦q]]^[svar:0↦
   patt_free_svar X] using gpi
IH2: Γ
⊢i ψ^[[evar:E↦q]]^[svar:0↦
   patt_free_svar X] --->
   ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] using gpi
well_formed_closed_mu_aux ψ^[[evar:E↦q]] 1
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := ~~
                 match
                   maximal_mu_depth_to sdepth E
                     ψ
                 with
                 | 0 => true
                 | S _ => false
                 end) gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls)
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls)
≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: ∀ X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := ~~ false)
  gpi
IH: Γ
⊢i ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] <--->
   ψ^[[evar:E↦q]]^[svar:0↦
   patt_free_svar X] using gpi
IH1: Γ
⊢i ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] --->
   ψ^[[evar:E↦q]]^[svar:0↦
   patt_free_svar X] using gpi
IH2: Γ
⊢i ψ^[[evar:E↦q]]^[svar:0↦
   patt_free_svar X] --->
   ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] using gpi
well_formed_closed_mu_aux ψ^[[evar:E↦p]] 1
      2-3: wf_auto2.
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := ~~
                 match
                   maximal_mu_depth_to sdepth E
                     ψ
                 with
                 | 0 => true
                 | S _ => false
                 end) gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls)
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls)
≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: ∀ X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := ~~ false)
  gpi
IH: Γ
⊢i ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] <--->
   ψ^[[evar:E↦q]]^[svar:0↦
   patt_free_svar X] using gpi
IH1: Γ
⊢i ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] --->
   ψ^[[evar:E↦q]]^[svar:0↦
   patt_free_svar X] using gpi
IH2: Γ
⊢i ψ^[[evar:E↦q]]^[svar:0↦
   patt_free_svar X] --->
   ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] using gpi
Γ
⊢i (mu , ψ^[[evar:E↦p]]^{svar:0↦X}^{{svar:X↦0}}) <--->
   (mu , ψ^[[evar:E↦q]]^{svar:0↦X}^{{svar:X↦0}})
using gpi
      
      apply pf_iff_split.
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := ~~
                 match
                   maximal_mu_depth_to sdepth E
                     ψ
                 with
                 | 0 => true
                 | S _ => false
                 end) gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls)
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls)
≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: ∀ X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := ~~ false)
  gpi
IH: Γ
⊢i ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] <--->
   ψ^[[evar:E↦q]]^[svar:0↦
   patt_free_svar X] using gpi
IH1: Γ
⊢i ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] --->
   ψ^[[evar:E↦q]]^[svar:0↦
   patt_free_svar X] using gpi
IH2: Γ
⊢i ψ^[[evar:E↦q]]^[svar:0↦
   patt_free_svar X] --->
   ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] using gpi
well_formed
  (mu , ψ^[[evar:E↦p]]^{svar:0↦X}^{{svar:X↦0}})
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := ~~
                 match
                   maximal_mu_depth_to sdepth E
                     ψ
                 with
                 | 0 => true
                 | S _ => false
                 end) gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls)
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls)
≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: ∀ X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := ~~ false)
  gpi
IH: Γ
⊢i ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] <--->
   ψ^[[evar:E↦q]]^[svar:0↦
   patt_free_svar X] using gpi
IH1: Γ
⊢i ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] --->
   ψ^[[evar:E↦q]]^[svar:0↦
   patt_free_svar X] using gpi
IH2: Γ
⊢i ψ^[[evar:E↦q]]^[svar:0↦
   patt_free_svar X] --->
   ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] using gpi
well_formed
  (mu , ψ^[[evar:E↦q]]^{svar:0↦X}^{{svar:X↦0}})
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := ~~
                 match
                   maximal_mu_depth_to sdepth E
                     ψ
                 with
                 | 0 => true
                 | S _ => false
                 end) gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls)
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls)
≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: ∀ X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := ~~ false)
  gpi
IH: Γ
⊢i ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] <--->
   ψ^[[evar:E↦q]]^[svar:0↦
   patt_free_svar X] using gpi
IH1: Γ
⊢i ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] --->
   ψ^[[evar:E↦q]]^[svar:0↦
   patt_free_svar X] using gpi
IH2: Γ
⊢i ψ^[[evar:E↦q]]^[svar:0↦
   patt_free_svar X] --->
   ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] using gpi
Γ
⊢i (mu , ψ^[[evar:E↦p]]^{svar:0↦X}^{{svar:X↦0}}) --->
   (mu , ψ^[[evar:E↦q]]^{svar:0↦X}^{{svar:X↦0}})
using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := ~~
                 match
                   maximal_mu_depth_to sdepth E
                     ψ
                 with
                 | 0 => true
                 | S _ => false
                 end) gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls)
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls)
≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: ∀ X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := ~~ false)
  gpi
IH: Γ
⊢i ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] <--->
   ψ^[[evar:E↦q]]^[svar:0↦
   patt_free_svar X] using gpi
IH1: Γ
⊢i ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] --->
   ψ^[[evar:E↦q]]^[svar:0↦
   patt_free_svar X] using gpi
IH2: Γ
⊢i ψ^[[evar:E↦q]]^[svar:0↦
   patt_free_svar X] --->
   ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] using gpi
Γ
⊢i (mu , ψ^[[evar:E↦q]]^{svar:0↦X}^{{svar:X↦0}}) --->
   (mu , ψ^[[evar:E↦p]]^{svar:0↦X}^{{svar:X↦0}})
using gpi
      4: {
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := ~~
                 match
                   maximal_mu_depth_to sdepth E
                     ψ
                 with
                 | 0 => true
                 | S _ => false
                 end) gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls)
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls)
≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: ∀ X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := ~~ false)
  gpi
IH: Γ
⊢i ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] <--->
   ψ^[[evar:E↦q]]^[svar:0↦
   patt_free_svar X] using gpi
IH1: Γ
⊢i ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] --->
   ψ^[[evar:E↦q]]^[svar:0↦
   patt_free_svar X] using gpi
IH2: Γ
⊢i ψ^[[evar:E↦q]]^[svar:0↦
   patt_free_svar X] --->
   ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] using gpi
Γ
⊢i (mu , ψ^[[evar:E↦q]]^{svar:0↦X}^{{svar:X↦0}}) --->
   (mu , ψ^[[evar:E↦p]]^{svar:0↦X}^{{svar:X↦0}})
using gpi
        apply mu_monotone.
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := ~~
                 match
                   maximal_mu_depth_to sdepth E
                     ψ
                 with
                 | 0 => true
                 | S _ => false
                 end) gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls)
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls)
≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: ∀ X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := ~~ false)
  gpi
IH: Γ
⊢i ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] <--->
   ψ^[[evar:E↦q]]^[svar:0↦
   patt_free_svar X] using gpi
IH1: Γ
⊢i ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] --->
   ψ^[[evar:E↦q]]^[svar:0↦
   patt_free_svar X] using gpi
IH2: Γ
⊢i ψ^[[evar:E↦q]]^[svar:0↦
   patt_free_svar X] --->
   ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] using gpi
ProofInfoLe (ExGen := ∅, SVSubst := {[X]}, KT := true)
  gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := ~~
                 match
                   maximal_mu_depth_to sdepth E
                     ψ
                 with
                 | 0 => true
                 | S _ => false
                 end) gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls)
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls)
≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: ∀ X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := ~~ false)
  gpi
IH: Γ
⊢i ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] <--->
   ψ^[[evar:E↦q]]^[svar:0↦
   patt_free_svar X] using gpi
IH1: Γ
⊢i ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] --->
   ψ^[[evar:E↦q]]^[svar:0↦
   patt_free_svar X] using gpi
IH2: Γ
⊢i ψ^[[evar:E↦q]]^[svar:0↦
   patt_free_svar X] --->
   ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] using gpi
svar_has_negative_occurrence X
  ψ^[[evar:E↦q]]^{svar:0↦X} = false
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := ~~
                 match
                   maximal_mu_depth_to sdepth E
                     ψ
                 with
                 | 0 => true
                 | S _ => false
                 end) gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls)
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls)
≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: ∀ X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := ~~ false)
  gpi
IH: Γ
⊢i ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] <--->
   ψ^[[evar:E↦q]]^[svar:0↦
   patt_free_svar X] using gpi
IH1: Γ
⊢i ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] --->
   ψ^[[evar:E↦q]]^[svar:0↦
   patt_free_svar X] using gpi
IH2: Γ
⊢i ψ^[[evar:E↦q]]^[svar:0↦
   patt_free_svar X] --->
   ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] using gpi
svar_has_negative_occurrence X
  ψ^[[evar:E↦p]]^{svar:0↦X} = false
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := ~~
                 match
                   maximal_mu_depth_to sdepth E
                     ψ
                 with
                 | 0 => true
                 | S _ => false
                 end) gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls)
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls)
≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: ∀ X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := ~~ false)
  gpi
IH: Γ
⊢i ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] <--->
   ψ^[[evar:E↦q]]^[svar:0↦
   patt_free_svar X] using gpi
IH1: Γ
⊢i ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] --->
   ψ^[[evar:E↦q]]^[svar:0↦
   patt_free_svar X] using gpi
IH2: Γ
⊢i ψ^[[evar:E↦q]]^[svar:0↦
   patt_free_svar X] --->
   ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] using gpi
Γ
⊢i ψ^[[evar:E↦q]]^{svar:0↦X} --->
   ψ^[[evar:E↦p]]^{svar:0↦X} using gpi
        4: {
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := ~~
                 match
                   maximal_mu_depth_to sdepth E
                     ψ
                 with
                 | 0 => true
                 | S _ => false
                 end) gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls)
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls)
≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: ∀ X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := ~~ false)
  gpi
IH: Γ
⊢i ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] <--->
   ψ^[[evar:E↦q]]^[svar:0↦
   patt_free_svar X] using gpi
IH1: Γ
⊢i ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] --->
   ψ^[[evar:E↦q]]^[svar:0↦
   patt_free_svar X] using gpi
IH2: Γ
⊢i ψ^[[evar:E↦q]]^[svar:0↦
   patt_free_svar X] --->
   ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] using gpi
Γ
⊢i ψ^[[evar:E↦q]]^{svar:0↦X} --->
   ψ^[[evar:E↦p]]^{svar:0↦X} using gpi
          unfold svar_open.
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := ~~
                 match
                   maximal_mu_depth_to sdepth E
                     ψ
                 with
                 | 0 => true
                 | S _ => false
                 end) gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls)
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls)
≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: ∀ X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := ~~ false)
  gpi
IH: Γ
⊢i ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] <--->
   ψ^[[evar:E↦q]]^[svar:0↦
   patt_free_svar X] using gpi
IH1: Γ
⊢i ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] --->
   ψ^[[evar:E↦q]]^[svar:0↦
   patt_free_svar X] using gpi
IH2: Γ
⊢i ψ^[[evar:E↦q]]^[svar:0↦
   patt_free_svar X] --->
   ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] using gpi
Γ
⊢i ψ^[[evar:E↦q]]^[svar:0↦patt_free_svar X] --->
   ψ^[[evar:E↦p]]^[svar:0↦patt_free_svar X] using gpi
          apply IH2.
        }
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := ~~
                 match
                   maximal_mu_depth_to sdepth E
                     ψ
                 with
                 | 0 => true
                 | S _ => false
                 end) gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls)
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls)
≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: ∀ X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := ~~ false)
  gpi
IH: Γ
⊢i ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] <--->
   ψ^[[evar:E↦q]]^[svar:0↦
   patt_free_svar X] using gpi
IH1: Γ
⊢i ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] --->
   ψ^[[evar:E↦q]]^[svar:0↦
   patt_free_svar X] using gpi
IH2: Γ
⊢i ψ^[[evar:E↦q]]^[svar:0↦
   patt_free_svar X] --->
   ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] using gpi
ProofInfoLe (ExGen := ∅, SVSubst := {[X]}, KT := true)
  gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := ~~
                 match
                   maximal_mu_depth_to sdepth E
                     ψ
                 with
                 | 0 => true
                 | S _ => false
                 end) gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls)
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls)
≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: ∀ X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := ~~ false)
  gpi
IH: Γ
⊢i ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] <--->
   ψ^[[evar:E↦q]]^[svar:0↦
   patt_free_svar X] using gpi
IH1: Γ
⊢i ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] --->
   ψ^[[evar:E↦q]]^[svar:0↦
   patt_free_svar X] using gpi
IH2: Γ
⊢i ψ^[[evar:E↦q]]^[svar:0↦
   patt_free_svar X] --->
   ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] using gpi
svar_has_negative_occurrence X
  ψ^[[evar:E↦q]]^{svar:0↦X} = false
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := ~~
                 match
                   maximal_mu_depth_to sdepth E
                     ψ
                 with
                 | 0 => true
                 | S _ => false
                 end) gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls)
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls)
≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: ∀ X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := ~~ false)
  gpi
IH: Γ
⊢i ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] <--->
   ψ^[[evar:E↦q]]^[svar:0↦
   patt_free_svar X] using gpi
IH1: Γ
⊢i ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] --->
   ψ^[[evar:E↦q]]^[svar:0↦
   patt_free_svar X] using gpi
IH2: Γ
⊢i ψ^[[evar:E↦q]]^[svar:0↦
   patt_free_svar X] --->
   ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] using gpi
svar_has_negative_occurrence X
  ψ^[[evar:E↦p]]^{svar:0↦X} = false
        2-3:
          abstract (
            destruct Hsl1 as [_ Hsl1];
            specialize (Hsl1 X ltac:(now left));
            clear -wfψ wfp wfq Hsl1;
            wf_auto2; intros; wf_auto2;
            cbn in *;
            pose proof (Htmp1 := free_svars_free_evar_subst ψ E p);
            pose proof (Htmp2 := free_svars_free_evar_subst ψ E q);
            unfold svar_is_fresh_in;
            set_solver
          ).
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := ~~
                 match
                   maximal_mu_depth_to sdepth E
                     ψ
                 with
                 | 0 => true
                 | S _ => false
                 end) gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls)
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls)
≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: ∀ X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := ~~ false)
  gpi
IH: Γ
⊢i ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] <--->
   ψ^[[evar:E↦q]]^[svar:0↦
   patt_free_svar X] using gpi
IH1: Γ
⊢i ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] --->
   ψ^[[evar:E↦q]]^[svar:0↦
   patt_free_svar X] using gpi
IH2: Γ
⊢i ψ^[[evar:E↦q]]^[svar:0↦
   patt_free_svar X] --->
   ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] using gpi
ProofInfoLe (ExGen := ∅, SVSubst := {[X]}, KT := true)
  gpi
        {
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := ~~
                 match
                   maximal_mu_depth_to sdepth E
                     ψ
                 with
                 | 0 => true
                 | S _ => false
                 end) gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls)
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls)
≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: ∀ X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := ~~ false)
  gpi
IH: Γ
⊢i ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] <--->
   ψ^[[evar:E↦q]]^[svar:0↦
   patt_free_svar X] using gpi
IH1: Γ
⊢i ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] --->
   ψ^[[evar:E↦q]]^[svar:0↦
   patt_free_svar X] using gpi
IH2: Γ
⊢i ψ^[[evar:E↦q]]^[svar:0↦
   patt_free_svar X] --->
   ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] using gpi
ProofInfoLe (ExGen := ∅, SVSubst := {[X]}, KT := true)
  gpi
          abstract (try_solve_pile).
        }
      }
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := ~~
                 match
                   maximal_mu_depth_to sdepth E
                     ψ
                 with
                 | 0 => true
                 | S _ => false
                 end) gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls)
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls)
≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: ∀ X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := ~~ false)
  gpi
IH: Γ
⊢i ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] <--->
   ψ^[[evar:E↦q]]^[svar:0↦
   patt_free_svar X] using gpi
IH1: Γ
⊢i ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] --->
   ψ^[[evar:E↦q]]^[svar:0↦
   patt_free_svar X] using gpi
IH2: Γ
⊢i ψ^[[evar:E↦q]]^[svar:0↦
   patt_free_svar X] --->
   ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] using gpi
well_formed
  (mu , ψ^[[evar:E↦p]]^{svar:0↦X}^{{svar:X↦0}})
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := ~~
                 match
                   maximal_mu_depth_to sdepth E
                     ψ
                 with
                 | 0 => true
                 | S _ => false
                 end) gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls)
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls)
≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: ∀ X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := ~~ false)
  gpi
IH: Γ
⊢i ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] <--->
   ψ^[[evar:E↦q]]^[svar:0↦
   patt_free_svar X] using gpi
IH1: Γ
⊢i ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] --->
   ψ^[[evar:E↦q]]^[svar:0↦
   patt_free_svar X] using gpi
IH2: Γ
⊢i ψ^[[evar:E↦q]]^[svar:0↦
   patt_free_svar X] --->
   ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] using gpi
well_formed
  (mu , ψ^[[evar:E↦q]]^{svar:0↦X}^{{svar:X↦0}})
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := ~~
                 match
                   maximal_mu_depth_to sdepth E
                     ψ
                 with
                 | 0 => true
                 | S _ => false
                 end) gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls)
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls)
≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: ∀ X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := ~~ false)
  gpi
IH: Γ
⊢i ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] <--->
   ψ^[[evar:E↦q]]^[svar:0↦
   patt_free_svar X] using gpi
IH1: Γ
⊢i ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] --->
   ψ^[[evar:E↦q]]^[svar:0↦
   patt_free_svar X] using gpi
IH2: Γ
⊢i ψ^[[evar:E↦q]]^[svar:0↦
   patt_free_svar X] --->
   ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] using gpi
Γ
⊢i (mu , ψ^[[evar:E↦p]]^{svar:0↦X}^{{svar:X↦0}}) --->
   (mu , ψ^[[evar:E↦q]]^{svar:0↦X}^{{svar:X↦0}})
using gpi
      3: {
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := ~~
                 match
                   maximal_mu_depth_to sdepth E
                     ψ
                 with
                 | 0 => true
                 | S _ => false
                 end) gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls)
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls)
≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: ∀ X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := ~~ false)
  gpi
IH: Γ
⊢i ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] <--->
   ψ^[[evar:E↦q]]^[svar:0↦
   patt_free_svar X] using gpi
IH1: Γ
⊢i ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] --->
   ψ^[[evar:E↦q]]^[svar:0↦
   patt_free_svar X] using gpi
IH2: Γ
⊢i ψ^[[evar:E↦q]]^[svar:0↦
   patt_free_svar X] --->
   ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] using gpi
Γ
⊢i (mu , ψ^[[evar:E↦p]]^{svar:0↦X}^{{svar:X↦0}}) --->
   (mu , ψ^[[evar:E↦q]]^{svar:0↦X}^{{svar:X↦0}})
using gpi
        apply mu_monotone.
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := ~~
                 match
                   maximal_mu_depth_to sdepth E
                     ψ
                 with
                 | 0 => true
                 | S _ => false
                 end) gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls)
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls)
≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: ∀ X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := ~~ false)
  gpi
IH: Γ
⊢i ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] <--->
   ψ^[[evar:E↦q]]^[svar:0↦
   patt_free_svar X] using gpi
IH1: Γ
⊢i ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] --->
   ψ^[[evar:E↦q]]^[svar:0↦
   patt_free_svar X] using gpi
IH2: Γ
⊢i ψ^[[evar:E↦q]]^[svar:0↦
   patt_free_svar X] --->
   ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] using gpi
ProofInfoLe (ExGen := ∅, SVSubst := {[X]}, KT := true)
  gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := ~~
                 match
                   maximal_mu_depth_to sdepth E
                     ψ
                 with
                 | 0 => true
                 | S _ => false
                 end) gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls)
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls)
≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: ∀ X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := ~~ false)
  gpi
IH: Γ
⊢i ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] <--->
   ψ^[[evar:E↦q]]^[svar:0↦
   patt_free_svar X] using gpi
IH1: Γ
⊢i ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] --->
   ψ^[[evar:E↦q]]^[svar:0↦
   patt_free_svar X] using gpi
IH2: Γ
⊢i ψ^[[evar:E↦q]]^[svar:0↦
   patt_free_svar X] --->
   ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] using gpi
svar_has_negative_occurrence X
  ψ^[[evar:E↦p]]^{svar:0↦X} = false
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := ~~
                 match
                   maximal_mu_depth_to sdepth E
                     ψ
                 with
                 | 0 => true
                 | S _ => false
                 end) gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls)
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls)
≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: ∀ X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := ~~ false)
  gpi
IH: Γ
⊢i ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] <--->
   ψ^[[evar:E↦q]]^[svar:0↦
   patt_free_svar X] using gpi
IH1: Γ
⊢i ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] --->
   ψ^[[evar:E↦q]]^[svar:0↦
   patt_free_svar X] using gpi
IH2: Γ
⊢i ψ^[[evar:E↦q]]^[svar:0↦
   patt_free_svar X] --->
   ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] using gpi
svar_has_negative_occurrence X
  ψ^[[evar:E↦q]]^{svar:0↦X} = false
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := ~~
                 match
                   maximal_mu_depth_to sdepth E
                     ψ
                 with
                 | 0 => true
                 | S _ => false
                 end) gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls)
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls)
≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: ∀ X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := ~~ false)
  gpi
IH: Γ
⊢i ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] <--->
   ψ^[[evar:E↦q]]^[svar:0↦
   patt_free_svar X] using gpi
IH1: Γ
⊢i ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] --->
   ψ^[[evar:E↦q]]^[svar:0↦
   patt_free_svar X] using gpi
IH2: Γ
⊢i ψ^[[evar:E↦q]]^[svar:0↦
   patt_free_svar X] --->
   ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] using gpi
Γ
⊢i ψ^[[evar:E↦p]]^{svar:0↦X} --->
   ψ^[[evar:E↦q]]^{svar:0↦X} using gpi
        4: {
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := ~~
                 match
                   maximal_mu_depth_to sdepth E
                     ψ
                 with
                 | 0 => true
                 | S _ => false
                 end) gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls)
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls)
≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: ∀ X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := ~~ false)
  gpi
IH: Γ
⊢i ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] <--->
   ψ^[[evar:E↦q]]^[svar:0↦
   patt_free_svar X] using gpi
IH1: Γ
⊢i ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] --->
   ψ^[[evar:E↦q]]^[svar:0↦
   patt_free_svar X] using gpi
IH2: Γ
⊢i ψ^[[evar:E↦q]]^[svar:0↦
   patt_free_svar X] --->
   ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] using gpi
Γ
⊢i ψ^[[evar:E↦p]]^{svar:0↦X} --->
   ψ^[[evar:E↦q]]^{svar:0↦X} using gpi
          unfold svar_open.
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := ~~
                 match
                   maximal_mu_depth_to sdepth E
                     ψ
                 with
                 | 0 => true
                 | S _ => false
                 end) gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls)
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls)
≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: ∀ X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := ~~ false)
  gpi
IH: Γ
⊢i ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] <--->
   ψ^[[evar:E↦q]]^[svar:0↦
   patt_free_svar X] using gpi
IH1: Γ
⊢i ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] --->
   ψ^[[evar:E↦q]]^[svar:0↦
   patt_free_svar X] using gpi
IH2: Γ
⊢i ψ^[[evar:E↦q]]^[svar:0↦
   patt_free_svar X] --->
   ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] using gpi
Γ
⊢i ψ^[[evar:E↦p]]^[svar:0↦patt_free_svar X] --->
   ψ^[[evar:E↦q]]^[svar:0↦patt_free_svar X] using gpi
          apply IH1.
        }
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := ~~
                 match
                   maximal_mu_depth_to sdepth E
                     ψ
                 with
                 | 0 => true
                 | S _ => false
                 end) gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls)
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls)
≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: ∀ X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := ~~ false)
  gpi
IH: Γ
⊢i ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] <--->
   ψ^[[evar:E↦q]]^[svar:0↦
   patt_free_svar X] using gpi
IH1: Γ
⊢i ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] --->
   ψ^[[evar:E↦q]]^[svar:0↦
   patt_free_svar X] using gpi
IH2: Γ
⊢i ψ^[[evar:E↦q]]^[svar:0↦
   patt_free_svar X] --->
   ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] using gpi
ProofInfoLe (ExGen := ∅, SVSubst := {[X]}, KT := true)
  gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := ~~
                 match
                   maximal_mu_depth_to sdepth E
                     ψ
                 with
                 | 0 => true
                 | S _ => false
                 end) gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls)
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls)
≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: ∀ X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := ~~ false)
  gpi
IH: Γ
⊢i ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] <--->
   ψ^[[evar:E↦q]]^[svar:0↦
   patt_free_svar X] using gpi
IH1: Γ
⊢i ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] --->
   ψ^[[evar:E↦q]]^[svar:0↦
   patt_free_svar X] using gpi
IH2: Γ
⊢i ψ^[[evar:E↦q]]^[svar:0↦
   patt_free_svar X] --->
   ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] using gpi
svar_has_negative_occurrence X
  ψ^[[evar:E↦p]]^{svar:0↦X} = false
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := ~~
                 match
                   maximal_mu_depth_to sdepth E
                     ψ
                 with
                 | 0 => true
                 | S _ => false
                 end) gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls)
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls)
≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: ∀ X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := ~~ false)
  gpi
IH: Γ
⊢i ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] <--->
   ψ^[[evar:E↦q]]^[svar:0↦
   patt_free_svar X] using gpi
IH1: Γ
⊢i ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] --->
   ψ^[[evar:E↦q]]^[svar:0↦
   patt_free_svar X] using gpi
IH2: Γ
⊢i ψ^[[evar:E↦q]]^[svar:0↦
   patt_free_svar X] --->
   ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] using gpi
svar_has_negative_occurrence X
  ψ^[[evar:E↦q]]^{svar:0↦X} = false
        2-3:
          abstract (
            destruct Hsl1 as [_ Hsl1];
            specialize (Hsl1 X ltac:(now left));
            clear -wfψ wfp wfq Hsl1;
            wf_auto2; intros; wf_auto2;
            cbn in *;
            pose proof (Htmp1 := free_svars_free_evar_subst ψ E p);
            pose proof (Htmp2 := free_svars_free_evar_subst ψ E q);
            unfold svar_is_fresh_in;
            set_solver
          ).
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := ~~
                 match
                   maximal_mu_depth_to sdepth E
                     ψ
                 with
                 | 0 => true
                 | S _ => false
                 end) gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls)
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls)
≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: ∀ X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := ~~ false)
  gpi
IH: Γ
⊢i ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] <--->
   ψ^[[evar:E↦q]]^[svar:0↦
   patt_free_svar X] using gpi
IH1: Γ
⊢i ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] --->
   ψ^[[evar:E↦q]]^[svar:0↦
   patt_free_svar X] using gpi
IH2: Γ
⊢i ψ^[[evar:E↦q]]^[svar:0↦
   patt_free_svar X] --->
   ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] using gpi
ProofInfoLe (ExGen := ∅, SVSubst := {[X]}, KT := true)
  gpi
          {
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := ~~
                 match
                   maximal_mu_depth_to sdepth E
                     ψ
                 with
                 | 0 => true
                 | S _ => false
                 end) gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls)
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls)
≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: ∀ X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := ~~ false)
  gpi
IH: Γ
⊢i ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] <--->
   ψ^[[evar:E↦q]]^[svar:0↦
   patt_free_svar X] using gpi
IH1: Γ
⊢i ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] --->
   ψ^[[evar:E↦q]]^[svar:0↦
   patt_free_svar X] using gpi
IH2: Γ
⊢i ψ^[[evar:E↦q]]^[svar:0↦
   patt_free_svar X] --->
   ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] using gpi
ProofInfoLe (ExGen := ∅, SVSubst := {[X]}, KT := true)
  gpi
            abstract (try_solve_pile).
          }
      }
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := ~~
                 match
                   maximal_mu_depth_to sdepth E
                     ψ
                 with
                 | 0 => true
                 | S _ => false
                 end) gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls)
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls)
≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: ∀ X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := ~~ false)
  gpi
IH: Γ
⊢i ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] <--->
   ψ^[[evar:E↦q]]^[svar:0↦
   patt_free_svar X] using gpi
IH1: Γ
⊢i ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] --->
   ψ^[[evar:E↦q]]^[svar:0↦
   patt_free_svar X] using gpi
IH2: Γ
⊢i ψ^[[evar:E↦q]]^[svar:0↦
   patt_free_svar X] --->
   ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] using gpi
well_formed
  (mu , ψ^[[evar:E↦p]]^{svar:0↦X}^{{svar:X↦0}})
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := ~~
                 match
                   maximal_mu_depth_to sdepth E
                     ψ
                 with
                 | 0 => true
                 | S _ => false
                 end) gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls)
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls)
≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: ∀ X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := ~~ false)
  gpi
IH: Γ
⊢i ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] <--->
   ψ^[[evar:E↦q]]^[svar:0↦
   patt_free_svar X] using gpi
IH1: Γ
⊢i ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] --->
   ψ^[[evar:E↦q]]^[svar:0↦
   patt_free_svar X] using gpi
IH2: Γ
⊢i ψ^[[evar:E↦q]]^[svar:0↦
   patt_free_svar X] --->
   ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] using gpi
well_formed
  (mu , ψ^[[evar:E↦q]]^{svar:0↦X}^{{svar:X↦0}})
      {
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := ~~
                 match
                   maximal_mu_depth_to sdepth E
                     ψ
                 with
                 | 0 => true
                 | S _ => false
                 end) gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls)
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls)
≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: ∀ X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := ~~ false)
  gpi
IH: Γ
⊢i ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] <--->
   ψ^[[evar:E↦q]]^[svar:0↦
   patt_free_svar X] using gpi
IH1: Γ
⊢i ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] --->
   ψ^[[evar:E↦q]]^[svar:0↦
   patt_free_svar X] using gpi
IH2: Γ
⊢i ψ^[[evar:E↦q]]^[svar:0↦
   patt_free_svar X] --->
   ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] using gpi
well_formed
  (mu , ψ^[[evar:E↦p]]^{svar:0↦X}^{{svar:X↦0}})
        cut (X ∉ free_svars ψ^[[evar:E↦p]]).
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := ~~
                 match
                   maximal_mu_depth_to sdepth E
                     ψ
                 with
                 | 0 => true
                 | S _ => false
                 end) gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls)
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls)
≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: ∀ X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := ~~ false)
  gpi
IH: Γ
⊢i ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] <--->
   ψ^[[evar:E↦q]]^[svar:0↦
   patt_free_svar X] using gpi
IH1: Γ
⊢i ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] --->
   ψ^[[evar:E↦q]]^[svar:0↦
   patt_free_svar X] using gpi
IH2: Γ
⊢i ψ^[[evar:E↦q]]^[svar:0↦
   patt_free_svar X] --->
   ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] using gpi
X ∉ free_svars ψ^[[evar:E↦p]]
→ well_formed
    (mu , ψ^[[evar:E↦p]]^{svar:0↦X}^{{svar:X↦0}})
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := ~~
                 match
                   maximal_mu_depth_to sdepth E
                     ψ
                 with
                 | 0 => true
                 | S _ => false
                 end) gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls)
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls)
≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: ∀ X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := ~~ false)
  gpi
IH: Γ
⊢i ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] <--->
   ψ^[[evar:E↦q]]^[svar:0↦
   patt_free_svar X] using gpi
IH1: Γ
⊢i ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] --->
   ψ^[[evar:E↦q]]^[svar:0↦
   patt_free_svar X] using gpi
IH2: Γ
⊢i ψ^[[evar:E↦q]]^[svar:0↦
   patt_free_svar X] --->
   ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] using gpi
X ∉ free_svars ψ^[[evar:E↦p]]
        {
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := ~~
                 match
                   maximal_mu_depth_to sdepth E
                     ψ
                 with
                 | 0 => true
                 | S _ => false
                 end) gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls)
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls)
≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: ∀ X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := ~~ false)
  gpi
IH: Γ
⊢i ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] <--->
   ψ^[[evar:E↦q]]^[svar:0↦
   patt_free_svar X] using gpi
IH1: Γ
⊢i ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] --->
   ψ^[[evar:E↦q]]^[svar:0↦
   patt_free_svar X] using gpi
IH2: Γ
⊢i ψ^[[evar:E↦q]]^[svar:0↦
   patt_free_svar X] --->
   ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] using gpi
X ∉ free_svars ψ^[[evar:E↦p]]
→ well_formed
    (mu , ψ^[[evar:E↦p]]^{svar:0↦X}^{{svar:X↦0}})
          clear -wfψ wfp.
Σ: Signature
p: Pattern
wfp: well_formed p
E: evar
ψ: Pattern
wfψ: well_formed (mu , ψ)
X: svar
X ∉ free_svars ψ^[[evar:E↦p]]
→ well_formed
    (mu , ψ^[[evar:E↦p]]^{svar:0↦X}^{{svar:X↦0}})
          intros.
Σ: Signature
p: Pattern
wfp: well_formed p
E: evar
ψ: Pattern
wfψ: well_formed (mu , ψ)
X: svar
H: X ∉ free_svars ψ^[[evar:E↦p]]
well_formed
  (mu , ψ^[[evar:E↦p]]^{svar:0↦X}^{{svar:X↦0}})
          (* TODO: this rewrite somewhy does not happen in wf_auto2 *)
          abstract (rewrite svar_quantify_svar_open;wf_auto2).
        }
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := ~~
                 match
                   maximal_mu_depth_to sdepth E
                     ψ
                 with
                 | 0 => true
                 | S _ => false
                 end) gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls)
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls)
≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: ∀ X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := ~~ false)
  gpi
IH: Γ
⊢i ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] <--->
   ψ^[[evar:E↦q]]^[svar:0↦
   patt_free_svar X] using gpi
IH1: Γ
⊢i ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] --->
   ψ^[[evar:E↦q]]^[svar:0↦
   patt_free_svar X] using gpi
IH2: Γ
⊢i ψ^[[evar:E↦q]]^[svar:0↦
   patt_free_svar X] --->
   ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] using gpi
X ∉ free_svars ψ^[[evar:E↦p]]
        abstract (
          pose proof (Htmp := free_svars_free_evar_subst ψ E p);
          destruct Hsl1 as [_ Hsl1];
          specialize (Hsl1 X ltac:(now left));
          clear -H Htmp ψ Hsl1;
          set_solver
        ).
      }
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := ~~
                 match
                   maximal_mu_depth_to sdepth E
                     ψ
                 with
                 | 0 => true
                 | S _ => false
                 end) gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls)
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls)
≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: ∀ X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := ~~ false)
  gpi
IH: Γ
⊢i ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] <--->
   ψ^[[evar:E↦q]]^[svar:0↦
   patt_free_svar X] using gpi
IH1: Γ
⊢i ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] --->
   ψ^[[evar:E↦q]]^[svar:0↦
   patt_free_svar X] using gpi
IH2: Γ
⊢i ψ^[[evar:E↦q]]^[svar:0↦
   patt_free_svar X] --->
   ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] using gpi
well_formed
  (mu , ψ^[[evar:E↦q]]^{svar:0↦X}^{{svar:X↦0}})
      {
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := ~~
                 match
                   maximal_mu_depth_to sdepth E
                     ψ
                 with
                 | 0 => true
                 | S _ => false
                 end) gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls)
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls)
≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: ∀ X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := ~~ false)
  gpi
IH: Γ
⊢i ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] <--->
   ψ^[[evar:E↦q]]^[svar:0↦
   patt_free_svar X] using gpi
IH1: Γ
⊢i ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] --->
   ψ^[[evar:E↦q]]^[svar:0↦
   patt_free_svar X] using gpi
IH2: Γ
⊢i ψ^[[evar:E↦q]]^[svar:0↦
   patt_free_svar X] --->
   ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] using gpi
well_formed
  (mu , ψ^[[evar:E↦q]]^{svar:0↦X}^{{svar:X↦0}})
        cut (X ∉ free_svars ψ^[[evar:E↦q]]).
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := ~~
                 match
                   maximal_mu_depth_to sdepth E
                     ψ
                 with
                 | 0 => true
                 | S _ => false
                 end) gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls)
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls)
≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: ∀ X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := ~~ false)
  gpi
IH: Γ
⊢i ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] <--->
   ψ^[[evar:E↦q]]^[svar:0↦
   patt_free_svar X] using gpi
IH1: Γ
⊢i ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] --->
   ψ^[[evar:E↦q]]^[svar:0↦
   patt_free_svar X] using gpi
IH2: Γ
⊢i ψ^[[evar:E↦q]]^[svar:0↦
   patt_free_svar X] --->
   ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] using gpi
X ∉ free_svars ψ^[[evar:E↦q]]
→ well_formed
    (mu , ψ^[[evar:E↦q]]^{svar:0↦X}^{{svar:X↦0}})
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := ~~
                 match
                   maximal_mu_depth_to sdepth E
                     ψ
                 with
                 | 0 => true
                 | S _ => false
                 end) gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls)
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls)
≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: ∀ X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := ~~ false)
  gpi
IH: Γ
⊢i ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] <--->
   ψ^[[evar:E↦q]]^[svar:0↦
   patt_free_svar X] using gpi
IH1: Γ
⊢i ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] --->
   ψ^[[evar:E↦q]]^[svar:0↦
   patt_free_svar X] using gpi
IH2: Γ
⊢i ψ^[[evar:E↦q]]^[svar:0↦
   patt_free_svar X] --->
   ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] using gpi
X ∉ free_svars ψ^[[evar:E↦q]]
        {
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := ~~
                 match
                   maximal_mu_depth_to sdepth E
                     ψ
                 with
                 | 0 => true
                 | S _ => false
                 end) gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls)
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls)
≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: ∀ X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := ~~ false)
  gpi
IH: Γ
⊢i ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] <--->
   ψ^[[evar:E↦q]]^[svar:0↦
   patt_free_svar X] using gpi
IH1: Γ
⊢i ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] --->
   ψ^[[evar:E↦q]]^[svar:0↦
   patt_free_svar X] using gpi
IH2: Γ
⊢i ψ^[[evar:E↦q]]^[svar:0↦
   patt_free_svar X] --->
   ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] using gpi
X ∉ free_svars ψ^[[evar:E↦q]]
→ well_formed
    (mu , ψ^[[evar:E↦q]]^{svar:0↦X}^{{svar:X↦0}})
          clear -wfψ wfq.
Σ: Signature
q: Pattern
wfq: well_formed q
E: evar
ψ: Pattern
wfψ: well_formed (mu , ψ)
X: svar
X ∉ free_svars ψ^[[evar:E↦q]]
→ well_formed
    (mu , ψ^[[evar:E↦q]]^{svar:0↦X}^{{svar:X↦0}})
          intros.
Σ: Signature
q: Pattern
wfq: well_formed q
E: evar
ψ: Pattern
wfψ: well_formed (mu , ψ)
X: svar
H: X ∉ free_svars ψ^[[evar:E↦q]]
well_formed
  (mu , ψ^[[evar:E↦q]]^{svar:0↦X}^{{svar:X↦0}})
          abstract (rewrite svar_quantify_svar_open; wf_auto2).
        }
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: ∀ (edepth sdepth : nat) (ψ : Pattern),
  well_formed ψ
  → size' ψ ≤ sz
    → ∀ (evs : coEVarSet) 
        (svs : coSVarSet) 
        (gpi : ProofInfo),
        ProofInfoLe
          (ExGen := evs, SVSubst := svs,
           KT := ~~
                 match
                   maximal_mu_depth_to sdepth E
                     ψ
                 with
                 | 0 => true
                 | S _ => false
                 end) gpi
        → Γ ⊢i p <---> q using gpi
          → ∀ el : list evar,
              fresh_evars el
                (free_evars ψ ∪ free_evars p
                 ∪ free_evars q ∪ {[E]})
              → length el
                ≥ maximal_exists_depth_to
                    edepth E ψ
                → (∀ x : evar, x ∈ el → x ∈ evs)
                  → ∀ sl : list svar,
                      fresh_svars sl
                        (free_svars ψ
                        ∪ 
                        free_svars p
                        ∪ 
                        free_svars q)
                      → length sl
                        ≥ 
                        maximal_mu_depth_to
                        sdepth E ψ
                        → 
                        (∀ X : svar,
                        X ∈ sl → X ∈ svs)
                        → 
                        Γ
                        ⊢i 
                        ψ^[[evar:E↦p]] <--->
                        ψ^[[evar:E↦q]]
                        using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el
  (free_evars ψ ∪ free_evars p ∪ free_evars q
   ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: ∀ x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls)
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls)
≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: ∀ X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe
  (ExGen := evs, SVSubst := svs, KT := ~~ false)
  gpi
IH: Γ
⊢i ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] <--->
   ψ^[[evar:E↦q]]^[svar:0↦
   patt_free_svar X] using gpi
IH1: Γ
⊢i ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] --->
   ψ^[[evar:E↦q]]^[svar:0↦
   patt_free_svar X] using gpi
IH2: Γ
⊢i ψ^[[evar:E↦q]]^[svar:0↦
   patt_free_svar X] --->
   ψ^[[evar:E↦p]]^[svar:0↦
   patt_free_svar X] using gpi
X ∉ free_svars ψ^[[evar:E↦q]]
        abstract (
          pose proof (Htmp := free_svars_free_evar_subst ψ E q);
          destruct Hsl1 as [_ Hsl1];
          specialize (Hsl1 X ltac:(now left));
          clear -H Htmp ψ Hsl1;
          set_solver
        ).
      }
    }
  Defined.

  (* Correctness of evar_fresh_seq *)
  Lemma evar_fresh_seq_correct n s:
    fresh_evars (evar_fresh_seq s n) s.
Σ: Signature
n: nat
s: EVarSet
fresh_evars (evar_fresh_seq s n) s
  Proof.
Σ: Signature
n: nat
s: EVarSet
fresh_evars (evar_fresh_seq s n) s
    move: s.
Σ: Signature
n: nat
∀ s : EVarSet, fresh_evars (evar_fresh_seq s n) s
    induction n; intro s; cbn.
Σ: Signature
s: EVarSet
fresh_evars [] s
Σ: Signature
n: nat
IHn: ∀ s : EVarSet, fresh_evars (evar_fresh_seq s n) s
s: EVarSet
fresh_evars
  (evar_fresh_s s
   :: evar_fresh_seq ({[evar_fresh_s s]} ∪ s) n) s
    *
Σ: Signature
s: EVarSet
fresh_evars [] s constructor; simpl.
Σ: Signature
s: EVarSet
True
Σ: Signature
s: EVarSet
∀ x : evar, x ∈ [] → x ∉ s trivial.
Σ: Signature
s: EVarSet
∀ x : evar, x ∈ [] → x ∉ s intros.
Σ: Signature
s: EVarSet
x: evar
H: x ∈ []
x ∉ s set_solver.
    *
Σ: Signature
n: nat
IHn: ∀ s : EVarSet, fresh_evars (evar_fresh_seq s n) s
s: EVarSet
fresh_evars
  (evar_fresh_s s
   :: evar_fresh_seq ({[evar_fresh_s s]} ∪ s) n) s destruct (IHn ({[evar_fresh_s s]} ∪ s)) as [Dups Fresh].
Σ: Signature
n: nat
IHn: ∀ s : EVarSet, fresh_evars (evar_fresh_seq s n) s
s: EVarSet
Dups: no_dups
  (evar_fresh_seq ({[evar_fresh_s s]} ∪ s) n)
Fresh: ∀ x : evar,
  x
  ∈ evar_fresh_seq ({[evar_fresh_s s]} ∪ s) n
  → x ∉ {[evar_fresh_s s]} ∪ s
fresh_evars
  (evar_fresh_s s
   :: evar_fresh_seq ({[evar_fresh_s s]} ∪ s) n) s constructor.
Σ: Signature
n: nat
IHn: ∀ s : EVarSet, fresh_evars (evar_fresh_seq s n) s
s: EVarSet
Dups: no_dups
  (evar_fresh_seq ({[evar_fresh_s s]} ∪ s) n)
Fresh: ∀ x : evar,
  x
  ∈ evar_fresh_seq ({[evar_fresh_s s]} ∪ s) n
  → x ∉ {[evar_fresh_s s]} ∪ s
no_dups
  (evar_fresh_s s
   :: evar_fresh_seq ({[evar_fresh_s s]} ∪ s) n)
Σ: Signature
n: nat
IHn: ∀ s : EVarSet,
  fresh_evars (evar_fresh_seq s n) s
s: EVarSet
Dups: no_dups
  (evar_fresh_seq ({[evar_fresh_s s]} ∪ s) n)
Fresh: ∀ x : evar,
  x
  ∈ evar_fresh_seq ({[evar_fresh_s s]} ∪ s) n
  → x ∉ {[evar_fresh_s s]} ∪ s
∀ x : evar,
  x
  ∈ evar_fresh_s s
    :: evar_fresh_seq ({[evar_fresh_s s]} ∪ s) n
  → x ∉ s
      -
Σ: Signature
n: nat
IHn: ∀ s : EVarSet, fresh_evars (evar_fresh_seq s n) s
s: EVarSet
Dups: no_dups
  (evar_fresh_seq ({[evar_fresh_s s]} ∪ s) n)
Fresh: ∀ x : evar,
  x
  ∈ evar_fresh_seq ({[evar_fresh_s s]} ∪ s) n
  → x ∉ {[evar_fresh_s s]} ∪ s
no_dups
  (evar_fresh_s s
   :: evar_fresh_seq ({[evar_fresh_s s]} ∪ s) n) simpl.
Σ: Signature
n: nat
IHn: ∀ s : EVarSet, fresh_evars (evar_fresh_seq s n) s
s: EVarSet
Dups: no_dups
  (evar_fresh_seq ({[evar_fresh_s s]} ∪ s) n)
Fresh: ∀ x : evar,
  x
  ∈ evar_fresh_seq ({[evar_fresh_s s]} ∪ s) n
  → x ∉ {[evar_fresh_s s]} ∪ s
(evar_fresh_s s
 ∉ evar_fresh_seq ({[evar_fresh_s s]} ∪ s) n)
∧ no_dups (evar_fresh_seq ({[evar_fresh_s s]} ∪ s) n) split; auto.
Σ: Signature
n: nat
IHn: ∀ s : EVarSet, fresh_evars (evar_fresh_seq s n) s
s: EVarSet
Dups: no_dups
  (evar_fresh_seq ({[evar_fresh_s s]} ∪ s) n)
Fresh: ∀ x : evar,
  x
  ∈ evar_fresh_seq ({[evar_fresh_s s]} ∪ s) n
  → x ∉ {[evar_fresh_s s]} ∪ s
evar_fresh_s s
∉ evar_fresh_seq ({[evar_fresh_s s]} ∪ s) n
        pose proof (evar_fresh_seq_disj ({[evar_fresh_s s]} ∪ s) n).
Σ: Signature
n: nat
IHn: ∀ s : EVarSet, fresh_evars (evar_fresh_seq s n) s
s: EVarSet
Dups: no_dups
  (evar_fresh_seq ({[evar_fresh_s s]} ∪ s) n)
Fresh: ∀ x : evar,
  x
  ∈ evar_fresh_seq ({[evar_fresh_s s]} ∪ s) n
  → x ∉ {[evar_fresh_s s]} ∪ s
H: list_to_set
  (evar_fresh_seq ({[evar_fresh_s s]} ∪ s) n)
## {[evar_fresh_s s]} ∪ s
evar_fresh_s s
∉ evar_fresh_seq ({[evar_fresh_s s]} ∪ s) n
        set_solver.
      -
Σ: Signature
n: nat
IHn: ∀ s : EVarSet, fresh_evars (evar_fresh_seq s n) s
s: EVarSet
Dups: no_dups
  (evar_fresh_seq ({[evar_fresh_s s]} ∪ s) n)
Fresh: ∀ x : evar,
  x
  ∈ evar_fresh_seq ({[evar_fresh_s s]} ∪ s) n
  → x ∉ {[evar_fresh_s s]} ∪ s
∀ x : evar,
  x
  ∈ evar_fresh_s s
    :: evar_fresh_seq ({[evar_fresh_s s]} ∪ s) n
  → x ∉ s intros.
Σ: Signature
n: nat
IHn: ∀ s : EVarSet, fresh_evars (evar_fresh_seq s n) s
s: EVarSet
Dups: no_dups
  (evar_fresh_seq ({[evar_fresh_s s]} ∪ s) n)
Fresh: ∀ x : evar,
  x
  ∈ evar_fresh_seq ({[evar_fresh_s s]} ∪ s) n
  → x ∉ {[evar_fresh_s s]} ∪ s
x: evar
H: x
∈ evar_fresh_s s
  :: evar_fresh_seq ({[evar_fresh_s s]} ∪ s) n
x ∉ s apply elem_of_cons in H as [H | H].
Σ: Signature
n: nat
IHn: ∀ s : EVarSet, fresh_evars (evar_fresh_seq s n) s
s: EVarSet
Dups: no_dups
  (evar_fresh_seq ({[evar_fresh_s s]} ∪ s) n)
Fresh: ∀ x : evar,
  x
  ∈ evar_fresh_seq ({[evar_fresh_s s]} ∪ s) n
  → x ∉ {[evar_fresh_s s]} ∪ s
x: evar
H: x = evar_fresh_s s
x ∉ s
Σ: Signature
n: nat
IHn: ∀ s : EVarSet,
  fresh_evars (evar_fresh_seq s n) s
s: EVarSet
Dups: no_dups
  (evar_fresh_seq ({[evar_fresh_s s]} ∪ s) n)
Fresh: ∀ x : evar,
  x
  ∈ evar_fresh_seq ({[evar_fresh_s s]} ∪ s) n
  → x ∉ {[evar_fresh_s s]} ∪ s
x: evar
H: x ∈ evar_fresh_seq ({[evar_fresh_s s]} ∪ s) n
x ∉ s
        +
Σ: Signature
n: nat
IHn: ∀ s : EVarSet, fresh_evars (evar_fresh_seq s n) s
s: EVarSet
Dups: no_dups
  (evar_fresh_seq ({[evar_fresh_s s]} ∪ s) n)
Fresh: ∀ x : evar,
  x
  ∈ evar_fresh_seq ({[evar_fresh_s s]} ∪ s) n
  → x ∉ {[evar_fresh_s s]} ∪ s
x: evar
H: x = evar_fresh_s s
x ∉ s subst.
Σ: Signature
n: nat
IHn: ∀ s : EVarSet, fresh_evars (evar_fresh_seq s n) s
s: EVarSet
Dups: no_dups
  (evar_fresh_seq ({[evar_fresh_s s]} ∪ s) n)
Fresh: ∀ x : evar,
  x
  ∈ evar_fresh_seq ({[evar_fresh_s s]} ∪ s) n
  → x ∉ {[evar_fresh_s s]} ∪ s
evar_fresh_s s ∉ s unfold evar_fresh_s.
Σ: Signature
n: nat
IHn: ∀ s : EVarSet, fresh_evars (evar_fresh_seq s n) s
s: EVarSet
Dups: no_dups
  (evar_fresh_seq ({[evar_fresh_s s]} ∪ s) n)
Fresh: ∀ x : evar,
  x
  ∈ evar_fresh_seq ({[evar_fresh_s s]} ∪ s) n
  → x ∉ {[evar_fresh_s s]} ∪ s
evar_fresh (elements s) ∉ s apply set_evar_fresh_is_fresh'.
        +
Σ: Signature
n: nat
IHn: ∀ s : EVarSet, fresh_evars (evar_fresh_seq s n) s
s: EVarSet
Dups: no_dups
  (evar_fresh_seq ({[evar_fresh_s s]} ∪ s) n)
Fresh: ∀ x : evar,
  x
  ∈ evar_fresh_seq ({[evar_fresh_s s]} ∪ s) n
  → x ∉ {[evar_fresh_s s]} ∪ s
x: evar
H: x ∈ evar_fresh_seq ({[evar_fresh_s s]} ∪ s) n
x ∉ s apply Fresh in H.
Σ: Signature
n: nat
IHn: ∀ s : EVarSet, fresh_evars (evar_fresh_seq s n) s
s: EVarSet
Dups: no_dups
  (evar_fresh_seq ({[evar_fresh_s s]} ∪ s) n)
Fresh: ∀ x : evar,
  x
  ∈ evar_fresh_seq ({[evar_fresh_s s]} ∪ s) n
  → x ∉ {[evar_fresh_s s]} ∪ s
x: evar
H: x ∉ {[evar_fresh_s s]} ∪ s
x ∉ s set_solver.
  Qed.

  (* Correctness of svar_fresh_seq *)
  Lemma svar_fresh_seq_correct n s:
    fresh_svars (svar_fresh_seq s n) s.
Σ: Signature
n: nat
s: SVarSet
fresh_svars (svar_fresh_seq s n) s
  Proof.
Σ: Signature
n: nat
s: SVarSet
fresh_svars (svar_fresh_seq s n) s
    move: s.
Σ: Signature
n: nat
∀ s : SVarSet, fresh_svars (svar_fresh_seq s n) s
    induction n; intro s; cbn.
Σ: Signature
s: SVarSet
fresh_svars [] s
Σ: Signature
n: nat
IHn: ∀ s : SVarSet, fresh_svars (svar_fresh_seq s n) s
s: SVarSet
fresh_svars
  (svar_fresh_s s
   :: svar_fresh_seq ({[svar_fresh_s s]} ∪ s) n) s
    *
Σ: Signature
s: SVarSet
fresh_svars [] s constructor; simpl.
Σ: Signature
s: SVarSet
True
Σ: Signature
s: SVarSet
∀ X : svar, X ∈ [] → X ∉ s trivial.
Σ: Signature
s: SVarSet
∀ X : svar, X ∈ [] → X ∉ s intros.
Σ: Signature
s: SVarSet
X: svar
H: X ∈ []
X ∉ s set_solver.
    *
Σ: Signature
n: nat
IHn: ∀ s : SVarSet, fresh_svars (svar_fresh_seq s n) s
s: SVarSet
fresh_svars
  (svar_fresh_s s
   :: svar_fresh_seq ({[svar_fresh_s s]} ∪ s) n) s destruct (IHn ({[svar_fresh_s s]} ∪ s)) as [Dups Fresh].
Σ: Signature
n: nat
IHn: ∀ s : SVarSet, fresh_svars (svar_fresh_seq s n) s
s: SVarSet
Dups: no_dups
  (svar_fresh_seq ({[svar_fresh_s s]} ∪ s) n)
Fresh: ∀ X : svar,
  X
  ∈ svar_fresh_seq ({[svar_fresh_s s]} ∪ s) n
  → X ∉ {[svar_fresh_s s]} ∪ s
fresh_svars
  (svar_fresh_s s
   :: svar_fresh_seq ({[svar_fresh_s s]} ∪ s) n) s constructor.
Σ: Signature
n: nat
IHn: ∀ s : SVarSet, fresh_svars (svar_fresh_seq s n) s
s: SVarSet
Dups: no_dups
  (svar_fresh_seq ({[svar_fresh_s s]} ∪ s) n)
Fresh: ∀ X : svar,
  X
  ∈ svar_fresh_seq ({[svar_fresh_s s]} ∪ s) n
  → X ∉ {[svar_fresh_s s]} ∪ s
no_dups
  (svar_fresh_s s
   :: svar_fresh_seq ({[svar_fresh_s s]} ∪ s) n)
Σ: Signature
n: nat
IHn: ∀ s : SVarSet,
  fresh_svars (svar_fresh_seq s n) s
s: SVarSet
Dups: no_dups
  (svar_fresh_seq ({[svar_fresh_s s]} ∪ s) n)
Fresh: ∀ X : svar,
  X
  ∈ svar_fresh_seq ({[svar_fresh_s s]} ∪ s) n
  → X ∉ {[svar_fresh_s s]} ∪ s
∀ X : svar,
  X
  ∈ svar_fresh_s s
    :: svar_fresh_seq ({[svar_fresh_s s]} ∪ s) n
  → X ∉ s
      -
Σ: Signature
n: nat
IHn: ∀ s : SVarSet, fresh_svars (svar_fresh_seq s n) s
s: SVarSet
Dups: no_dups
  (svar_fresh_seq ({[svar_fresh_s s]} ∪ s) n)
Fresh: ∀ X : svar,
  X
  ∈ svar_fresh_seq ({[svar_fresh_s s]} ∪ s) n
  → X ∉ {[svar_fresh_s s]} ∪ s
no_dups
  (svar_fresh_s s
   :: svar_fresh_seq ({[svar_fresh_s s]} ∪ s) n) simpl.
Σ: Signature
n: nat
IHn: ∀ s : SVarSet, fresh_svars (svar_fresh_seq s n) s
s: SVarSet
Dups: no_dups
  (svar_fresh_seq ({[svar_fresh_s s]} ∪ s) n)
Fresh: ∀ X : svar,
  X
  ∈ svar_fresh_seq ({[svar_fresh_s s]} ∪ s) n
  → X ∉ {[svar_fresh_s s]} ∪ s
(svar_fresh_s s
 ∉ svar_fresh_seq ({[svar_fresh_s s]} ∪ s) n)
∧ no_dups (svar_fresh_seq ({[svar_fresh_s s]} ∪ s) n) split; auto.
Σ: Signature
n: nat
IHn: ∀ s : SVarSet, fresh_svars (svar_fresh_seq s n) s
s: SVarSet
Dups: no_dups
  (svar_fresh_seq ({[svar_fresh_s s]} ∪ s) n)
Fresh: ∀ X : svar,
  X
  ∈ svar_fresh_seq ({[svar_fresh_s s]} ∪ s) n
  → X ∉ {[svar_fresh_s s]} ∪ s
svar_fresh_s s
∉ svar_fresh_seq ({[svar_fresh_s s]} ∪ s) n
        pose proof (svar_fresh_seq_disj ({[svar_fresh_s s]} ∪ s) n).
Σ: Signature
n: nat
IHn: ∀ s : SVarSet, fresh_svars (svar_fresh_seq s n) s
s: SVarSet
Dups: no_dups
  (svar_fresh_seq ({[svar_fresh_s s]} ∪ s) n)
Fresh: ∀ X : svar,
  X
  ∈ svar_fresh_seq ({[svar_fresh_s s]} ∪ s) n
  → X ∉ {[svar_fresh_s s]} ∪ s
H: list_to_set
  (svar_fresh_seq ({[svar_fresh_s s]} ∪ s) n)
## {[svar_fresh_s s]} ∪ s
svar_fresh_s s
∉ svar_fresh_seq ({[svar_fresh_s s]} ∪ s) n
        set_solver.
      -
Σ: Signature
n: nat
IHn: ∀ s : SVarSet, fresh_svars (svar_fresh_seq s n) s
s: SVarSet
Dups: no_dups
  (svar_fresh_seq ({[svar_fresh_s s]} ∪ s) n)
Fresh: ∀ X : svar,
  X
  ∈ svar_fresh_seq ({[svar_fresh_s s]} ∪ s) n
  → X ∉ {[svar_fresh_s s]} ∪ s
∀ X : svar,
  X
  ∈ svar_fresh_s s
    :: svar_fresh_seq ({[svar_fresh_s s]} ∪ s) n
  → X ∉ s intros.
Σ: Signature
n: nat
IHn: ∀ s : SVarSet, fresh_svars (svar_fresh_seq s n) s
s: SVarSet
Dups: no_dups
  (svar_fresh_seq ({[svar_fresh_s s]} ∪ s) n)
Fresh: ∀ X : svar,
  X
  ∈ svar_fresh_seq ({[svar_fresh_s s]} ∪ s) n
  → X ∉ {[svar_fresh_s s]} ∪ s
X: svar
H: X
∈ svar_fresh_s s
  :: svar_fresh_seq ({[svar_fresh_s s]} ∪ s) n
X ∉ s apply elem_of_cons in H as [H | H].
Σ: Signature
n: nat
IHn: ∀ s : SVarSet, fresh_svars (svar_fresh_seq s n) s
s: SVarSet
Dups: no_dups
  (svar_fresh_seq ({[svar_fresh_s s]} ∪ s) n)
Fresh: ∀ X : svar,
  X
  ∈ svar_fresh_seq ({[svar_fresh_s s]} ∪ s) n
  → X ∉ {[svar_fresh_s s]} ∪ s
X: svar
H: X = svar_fresh_s s
X ∉ s
Σ: Signature
n: nat
IHn: ∀ s : SVarSet,
  fresh_svars (svar_fresh_seq s n) s
s: SVarSet
Dups: no_dups
  (svar_fresh_seq ({[svar_fresh_s s]} ∪ s) n)
Fresh: ∀ X : svar,
  X
  ∈ svar_fresh_seq ({[svar_fresh_s s]} ∪ s) n
  → X ∉ {[svar_fresh_s s]} ∪ s
X: svar
H: X ∈ svar_fresh_seq ({[svar_fresh_s s]} ∪ s) n
X ∉ s
        +
Σ: Signature
n: nat
IHn: ∀ s : SVarSet, fresh_svars (svar_fresh_seq s n) s
s: SVarSet
Dups: no_dups
  (svar_fresh_seq ({[svar_fresh_s s]} ∪ s) n)
Fresh: ∀ X : svar,
  X
  ∈ svar_fresh_seq ({[svar_fresh_s s]} ∪ s) n
  → X ∉ {[svar_fresh_s s]} ∪ s
X: svar
H: X = svar_fresh_s s
X ∉ s subst.
Σ: Signature
n: nat
IHn: ∀ s : SVarSet, fresh_svars (svar_fresh_seq s n) s
s: SVarSet
Dups: no_dups
  (svar_fresh_seq ({[svar_fresh_s s]} ∪ s) n)
Fresh: ∀ X : svar,
  X
  ∈ svar_fresh_seq ({[svar_fresh_s s]} ∪ s) n
  → X ∉ {[svar_fresh_s s]} ∪ s
svar_fresh_s s ∉ s unfold svar_fresh_s.
Σ: Signature
n: nat
IHn: ∀ s : SVarSet, fresh_svars (svar_fresh_seq s n) s
s: SVarSet
Dups: no_dups
  (svar_fresh_seq ({[svar_fresh_s s]} ∪ s) n)
Fresh: ∀ X : svar,
  X
  ∈ svar_fresh_seq ({[svar_fresh_s s]} ∪ s) n
  → X ∉ {[svar_fresh_s s]} ∪ s
svar_fresh (elements s) ∉ s apply set_svar_fresh_is_fresh'.
        +
Σ: Signature
n: nat
IHn: ∀ s : SVarSet, fresh_svars (svar_fresh_seq s n) s
s: SVarSet
Dups: no_dups
  (svar_fresh_seq ({[svar_fresh_s s]} ∪ s) n)
Fresh: ∀ X : svar,
  X
  ∈ svar_fresh_seq ({[svar_fresh_s s]} ∪ s) n
  → X ∉ {[svar_fresh_s s]} ∪ s
X: svar
H: X ∈ svar_fresh_seq ({[svar_fresh_s s]} ∪ s) n
X ∉ s apply Fresh in H.
Σ: Signature
n: nat
IHn: ∀ s : SVarSet, fresh_svars (svar_fresh_seq s n) s
s: SVarSet
Dups: no_dups
  (svar_fresh_seq ({[svar_fresh_s s]} ∪ s) n)
Fresh: ∀ X : svar,
  X
  ∈ svar_fresh_seq ({[svar_fresh_s s]} ∪ s) n
  → X ∉ {[svar_fresh_s s]} ∪ s
X: svar
H: X ∉ {[svar_fresh_s s]} ∪ s
X ∉ s set_solver.
  Qed.

  Lemma evar_fresh_seq_length l n:
    length (evar_fresh_seq l n) = n.
Σ: Signature
l: EVarSet
n: nat
length (evar_fresh_seq l n) = n
  Proof.
Σ: Signature
l: EVarSet
n: nat
length (evar_fresh_seq l n) = n
    move: l.
Σ: Signature
n: nat
∀ l : EVarSet, length (evar_fresh_seq l n) = n
    induction n; intro l; simpl; auto.
  Qed.

  Lemma svar_fresh_seq_length l n:
    length (svar_fresh_seq l n) = n.
Σ: Signature
l: SVarSet
n: nat
length (svar_fresh_seq l n) = n
  Proof.
Σ: Signature
l: SVarSet
n: nat
length (svar_fresh_seq l n) = n
    move: l.
Σ: Signature
n: nat
∀ l : SVarSet, length (svar_fresh_seq l n) = n
    induction n; intro l; simpl; auto.
  Qed.

  Lemma prf_equiv_congruence Γ p q C
    (gpi : ProofInfo)
    (wfp : well_formed p = true)
    (wfq : well_formed q = true)
    (wfC: PC_wf C)
    (pile : ProofInfoLe
       (ExGen := list_to_set (evar_fresh_seq (free_evars (pcPattern C) ∪ free_evars p ∪ free_evars q ∪ {[pcEvar C]}) (maximal_exists_depth_to 0 (pcEvar C) (pcPattern C))),
       SVSubst := list_to_set (svar_fresh_seq (free_svars (pcPattern C) ∪ free_svars p ∪ free_svars q) (maximal_mu_depth_to 0 (pcEvar C) (pcPattern C))),
       KT := mu_in_evar_path (pcEvar C) (pcPattern C) 0
       )
      gpi
    ) :
      Γ ⊢i (p <---> q) using ( gpi) ->
      Γ ⊢i (((emplace C p) <---> (emplace C q))) using ( gpi).
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
gpi: ProofInfo
wfp: well_formed p = true
wfq: well_formed q = true
wfC: PC_wf C
pile: ProofInfoLe
  (ExGen := list_to_set
              (evar_fresh_seq
                 (free_evars (pcPattern C)
                  ∪ free_evars p ∪ 
                  free_evars q ∪ {[
                  pcEvar C]})
                 (maximal_exists_depth_to 0
                    (pcEvar C) 
                    (pcPattern C))),
   SVSubst := list_to_set
                (svar_fresh_seq
                   (free_svars (pcPattern C)
                    ∪ free_svars p
                    ∪ free_svars q)
                   (maximal_mu_depth_to 0
                      (pcEvar C) 
                      (pcPattern C))),
   KT := mu_in_evar_path 
           (pcEvar C) (pcPattern C) 0) gpi
Γ ⊢i p <---> q using gpi
→ Γ ⊢i (C [p]) <---> (C [q]) using gpi
  Proof.
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
gpi: ProofInfo
wfp: well_formed p = true
wfq: well_formed q = true
wfC: PC_wf C
pile: ProofInfoLe
  (ExGen := list_to_set
              (evar_fresh_seq
                 (free_evars (pcPattern C)
                  ∪ free_evars p ∪ 
                  free_evars q ∪ {[
                  pcEvar C]})
                 (maximal_exists_depth_to 0
                    (pcEvar C) 
                    (pcPattern C))),
   SVSubst := list_to_set
                (svar_fresh_seq
                   (free_svars (pcPattern C)
                    ∪ free_svars p
                    ∪ free_svars q)
                   (maximal_mu_depth_to 0
                      (pcEvar C) 
                      (pcPattern C))),
   KT := mu_in_evar_path 
           (pcEvar C) (pcPattern C) 0) gpi
Γ ⊢i p <---> q using gpi
→ Γ ⊢i (C [p]) <---> (C [q]) using gpi
    intros Hiff.
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
gpi: ProofInfo
wfp: well_formed p = true
wfq: well_formed q = true
wfC: PC_wf C
pile: ProofInfoLe
  (ExGen := list_to_set
              (evar_fresh_seq
                 (free_evars (pcPattern C)
                  ∪ free_evars p ∪ 
                  free_evars q ∪ {[
                  pcEvar C]})
                 (maximal_exists_depth_to 0
                    (pcEvar C) 
                    (pcPattern C))),
   SVSubst := list_to_set
                (svar_fresh_seq
                   (free_svars (pcPattern C)
                    ∪ free_svars p
                    ∪ free_svars q)
                   (maximal_mu_depth_to 0
                      (pcEvar C) 
                      (pcPattern C))),
   KT := mu_in_evar_path 
           (pcEvar C) (pcPattern C) 0) gpi
Hiff: Γ ⊢i p <---> q using gpi
Γ ⊢i (C [p]) <---> (C [q]) using gpi
    assert (well_formed (p <---> q)).
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
gpi: ProofInfo
wfp: well_formed p = true
wfq: well_formed q = true
wfC: PC_wf C
pile: ProofInfoLe
  (ExGen := list_to_set
              (evar_fresh_seq
                 (free_evars (pcPattern C)
                  ∪ free_evars p ∪ 
                  free_evars q ∪ {[
                  pcEvar C]})
                 (maximal_exists_depth_to 0
                    (pcEvar C) 
                    (pcPattern C))),
   SVSubst := list_to_set
                (svar_fresh_seq
                   (free_svars (pcPattern C)
                    ∪ free_svars p
                    ∪ free_svars q)
                   (maximal_mu_depth_to 0
                      (pcEvar C) 
                      (pcPattern C))),
   KT := mu_in_evar_path 
           (pcEvar C) (pcPattern C) 0) gpi
Hiff: Γ ⊢i p <---> q using gpi
well_formed (p <---> q)
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
gpi: ProofInfo
wfp: well_formed p = true
wfq: well_formed q = true
wfC: PC_wf C
pile: ProofInfoLe
  (ExGen := list_to_set
              (evar_fresh_seq
                 (free_evars (pcPattern C)
                  ∪ free_evars p ∪ 
                  free_evars q ∪ {[
                  pcEvar C]})
                 (maximal_exists_depth_to 0
                    (pcEvar C) 
                    (pcPattern C))),
   SVSubst := list_to_set
                (svar_fresh_seq
                   (free_svars (pcPattern C)
                    ∪ free_svars p
                    ∪ free_svars q)
                   (maximal_mu_depth_to 0
                      (pcEvar C) 
                      (pcPattern C))),
   KT := mu_in_evar_path 
           (pcEvar C) (pcPattern C) 0) gpi
Hiff: Γ ⊢i p <---> q using gpi
H: well_formed (p <---> q)
Γ ⊢i (C [p]) <---> (C [q]) using gpi
    {
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
gpi: ProofInfo
wfp: well_formed p = true
wfq: well_formed q = true
wfC: PC_wf C
pile: ProofInfoLe
  (ExGen := list_to_set
              (evar_fresh_seq
                 (free_evars (pcPattern C)
                  ∪ free_evars p ∪ 
                  free_evars q ∪ {[
                  pcEvar C]})
                 (maximal_exists_depth_to 0
                    (pcEvar C) 
                    (pcPattern C))),
   SVSubst := list_to_set
                (svar_fresh_seq
                   (free_svars (pcPattern C)
                    ∪ free_svars p
                    ∪ free_svars q)
                   (maximal_mu_depth_to 0
                      (pcEvar C) 
                      (pcPattern C))),
   KT := mu_in_evar_path 
           (pcEvar C) (pcPattern C) 0) gpi
Hiff: Γ ⊢i p <---> q using gpi
well_formed (p <---> q) abstract (
        pose proof (proved_impl_wf _ _ (proj1_sig Hiff));
        assumption
      ).
    }
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
gpi: ProofInfo
wfp: well_formed p = true
wfq: well_formed q = true
wfC: PC_wf C
pile: ProofInfoLe
  (ExGen := list_to_set
              (evar_fresh_seq
                 (free_evars (pcPattern C)
                  ∪ free_evars p ∪ 
                  free_evars q ∪ {[
                  pcEvar C]})
                 (maximal_exists_depth_to 0
                    (pcEvar C) 
                    (pcPattern C))),
   SVSubst := list_to_set
                (svar_fresh_seq
                   (free_svars (pcPattern C)
                    ∪ free_svars p
                    ∪ free_svars q)
                   (maximal_mu_depth_to 0
                      (pcEvar C) 
                      (pcPattern C))),
   KT := mu_in_evar_path 
           (pcEvar C) (pcPattern C) 0) gpi
Hiff: Γ ⊢i p <---> q using gpi
H: well_formed (p <---> q)
Γ ⊢i (C [p]) <---> (C [q]) using gpi
    assert (well_formed p) by (abstract (wf_auto2)).
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
gpi: ProofInfo
wfp: well_formed p = true
wfq: well_formed q = true
wfC: PC_wf C
pile: ProofInfoLe
  (ExGen := list_to_set
              (evar_fresh_seq
                 (free_evars (pcPattern C)
                  ∪ free_evars p ∪ 
                  free_evars q ∪ {[
                  pcEvar C]})
                 (maximal_exists_depth_to 0
                    (pcEvar C) 
                    (pcPattern C))),
   SVSubst := list_to_set
                (svar_fresh_seq
                   (free_svars (pcPattern C)
                    ∪ free_svars p
                    ∪ free_svars q)
                   (maximal_mu_depth_to 0
                      (pcEvar C) 
                      (pcPattern C))),
   KT := mu_in_evar_path 
           (pcEvar C) (pcPattern C) 0) gpi
Hiff: Γ ⊢i p <---> q using gpi
H: well_formed (p <---> q)
H0: well_formed p
Γ ⊢i (C [p]) <---> (C [q]) using gpi
    assert (well_formed q) by (abstract (wf_auto2)).
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
gpi: ProofInfo
wfp: well_formed p = true
wfq: well_formed q = true
wfC: PC_wf C
pile: ProofInfoLe
  (ExGen := list_to_set
              (evar_fresh_seq
                 (free_evars (pcPattern C)
                  ∪ free_evars p ∪ 
                  free_evars q ∪ {[
                  pcEvar C]})
                 (maximal_exists_depth_to 0
                    (pcEvar C) 
                    (pcPattern C))),
   SVSubst := list_to_set
                (svar_fresh_seq
                   (free_svars (pcPattern C)
                    ∪ free_svars p
                    ∪ free_svars q)
                   (maximal_mu_depth_to 0
                      (pcEvar C) 
                      (pcPattern C))),
   KT := mu_in_evar_path 
           (pcEvar C) (pcPattern C) 0) gpi
Hiff: Γ ⊢i p <---> q using gpi
H: well_formed (p <---> q)
H0: well_formed p
H1: well_formed q
Γ ⊢i (C [p]) <---> (C [q]) using gpi
    destruct C as [E ψ].
Σ: Signature
Γ: Theory
p, q: Pattern
E: evar
ψ: Pattern
gpi: ProofInfo
wfp: well_formed p = true
wfq: well_formed q = true
wfC: PC_wf {| pcEvar := E; pcPattern := ψ |}
pile: ProofInfoLe
  (ExGen := list_to_set
              (evar_fresh_seq
                 (free_evars
                    (pcPattern
                       {|
                        pcEvar := E;
                        pcPattern := ψ
                       |}) ∪ 
                  free_evars p ∪ 
                  free_evars q
                  ∪ {[pcEvar
                        {|
                        pcEvar := E;
                        pcPattern := ψ
                        |}]})
                 (maximal_exists_depth_to 0
                    (pcEvar
                       {|
                        pcEvar := E;
                        pcPattern := ψ
                       |})
                    (pcPattern
                       {|
                        pcEvar := E;
                        pcPattern := ψ
                       |}))),
   SVSubst := list_to_set
                (svar_fresh_seq
                   (free_svars
                      (pcPattern
                        {|
                        pcEvar := E;
                        pcPattern := ψ
                        |}) ∪ 
                    free_svars p ∪ 
                    free_svars q)
                   (maximal_mu_depth_to 0
                      (pcEvar
                        {|
                        pcEvar := E;
                        pcPattern := ψ
                        |})
                      (pcPattern
                        {|
                        pcEvar := E;
                        pcPattern := ψ
                        |}))),
   KT := mu_in_evar_path
           (pcEvar
              {| pcEvar := E; pcPattern := ψ |})
           (pcPattern
              {| pcEvar := E; pcPattern := ψ |})
           0) gpi
Hiff: Γ ⊢i p <---> q using gpi
H: well_formed (p <---> q)
H0: well_formed p
H1: well_formed q
Γ
⊢i ({| pcEvar := E; pcPattern := ψ |} [p]) <--->
   ({| pcEvar := E; pcPattern := ψ |} [q]) using gpi simpl in *.
Σ: Signature
Γ: Theory
p, q: Pattern
E: evar
ψ: Pattern
gpi: ProofInfo
wfp: well_formed p = true
wfq: well_formed q = true
wfC: PC_wf {| pcEvar := E; pcPattern := ψ |}
pile: ProofInfoLe
  (ExGen := list_to_set
              (evar_fresh_seq
                 (free_evars ψ ∪ free_evars p
                  ∪ free_evars q ∪ {[E]})
                 (maximal_exists_depth_to 0 E ψ)),
   SVSubst := list_to_set
                (svar_fresh_seq
                   (free_svars ψ ∪ free_svars p
                    ∪ free_svars q)
                   (maximal_mu_depth_to 0 E ψ)),
   KT := mu_in_evar_path E ψ 0) gpi
Hiff: Γ ⊢i p <---> q using gpi
H: well_formed (p <---> q)
H0: well_formed p
H1: well_formed q
Γ
⊢i ({| pcEvar := E; pcPattern := ψ |} [p]) <--->
   ({| pcEvar := E; pcPattern := ψ |} [q]) using gpi
    unfold emplace.
Σ: Signature
Γ: Theory
p, q: Pattern
E: evar
ψ: Pattern
gpi: ProofInfo
wfp: well_formed p = true
wfq: well_formed q = true
wfC: PC_wf {| pcEvar := E; pcPattern := ψ |}
pile: ProofInfoLe
  (ExGen := list_to_set
              (evar_fresh_seq
                 (free_evars ψ ∪ free_evars p
                  ∪ free_evars q ∪ {[E]})
                 (maximal_exists_depth_to 0 E ψ)),
   SVSubst := list_to_set
                (svar_fresh_seq
                   (free_svars ψ ∪ free_svars p
                    ∪ free_svars q)
                   (maximal_mu_depth_to 0 E ψ)),
   KT := mu_in_evar_path E ψ 0) gpi
Hiff: Γ ⊢i p <---> q using gpi
H: well_formed (p <---> q)
H0: well_formed p
H1: well_formed q
Γ
⊢i (pcPattern {| pcEvar := E; pcPattern := ψ |})^[[evar:
   pcEvar {| pcEvar := E; pcPattern := ψ |}↦p]] <--->
   (pcPattern {| pcEvar := E; pcPattern := ψ |})^[[evar:
   pcEvar {| pcEvar := E; pcPattern := ψ |}↦q]]
using gpi simpl.
Σ: Signature
Γ: Theory
p, q: Pattern
E: evar
ψ: Pattern
gpi: ProofInfo
wfp: well_formed p = true
wfq: well_formed q = true
wfC: PC_wf {| pcEvar := E; pcPattern := ψ |}
pile: ProofInfoLe
  (ExGen := list_to_set
              (evar_fresh_seq
                 (free_evars ψ ∪ free_evars p
                  ∪ free_evars q ∪ {[E]})
                 (maximal_exists_depth_to 0 E ψ)),
   SVSubst := list_to_set
                (svar_fresh_seq
                   (free_svars ψ ∪ free_svars p
                    ∪ free_svars q)
                   (maximal_mu_depth_to 0 E ψ)),
   KT := mu_in_evar_path E ψ 0) gpi
Hiff: Γ ⊢i p <---> q using gpi
H: well_formed (p <---> q)
H0: well_formed p
H1: well_formed q
Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
    eapply eq_prf_equiv_congruence with 
      (el := evar_fresh_seq (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
      (maximal_exists_depth_to 0 E ψ))
      (sl := svar_fresh_seq (free_svars ψ ∪ free_svars p ∪ free_svars q)
      (maximal_mu_depth_to 0 E ψ))
      (evs := list_to_set (evar_fresh_seq (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
      (maximal_exists_depth_to 0 E ψ)))
      (svs := list_to_set (svar_fresh_seq (free_svars ψ ∪ free_svars p ∪ free_svars q)
      (maximal_mu_depth_to 0 E ψ))); try assumption.
Σ: Signature
Γ: Theory
p, q: Pattern
E: evar
ψ: Pattern
gpi: ProofInfo
wfp: well_formed p = true
wfq: well_formed q = true
wfC: PC_wf {| pcEvar := E; pcPattern := ψ |}
pile: ProofInfoLe
  (ExGen := list_to_set
              (evar_fresh_seq
                 (free_evars ψ ∪ free_evars p
                  ∪ free_evars q ∪ {[E]})
                 (maximal_exists_depth_to 0 E ψ)),
   SVSubst := list_to_set
                (svar_fresh_seq
                   (free_svars ψ ∪ free_svars p
                    ∪ free_svars q)
                   (maximal_mu_depth_to 0 E ψ)),
   KT := mu_in_evar_path E ψ 0) gpi
Hiff: Γ ⊢i p <---> q using gpi
H: well_formed (p <---> q)
H0: well_formed p
H1: well_formed q
size' ψ ≤ ?sz
Σ: Signature
Γ: Theory
p, q: Pattern
E: evar
ψ: Pattern
gpi: ProofInfo
wfp: well_formed p = true
wfq: well_formed q = true
wfC: PC_wf {| pcEvar := E; pcPattern := ψ |}
pile: ProofInfoLe
  (ExGen := list_to_set
              (evar_fresh_seq
                 (free_evars ψ ∪ free_evars p
                  ∪ free_evars q ∪ {[E]})
                 (maximal_exists_depth_to 0 E ψ)),
   SVSubst := list_to_set
                (svar_fresh_seq
                   (free_svars ψ ∪ free_svars p
                    ∪ free_svars q)
                   (maximal_mu_depth_to 0 E ψ)),
   KT := mu_in_evar_path E ψ 0) gpi
Hiff: Γ ⊢i p <---> q using gpi
H: well_formed (p <---> q)
H0: well_formed p
H1: well_formed q
fresh_evars
  (evar_fresh_seq
     (free_evars ψ ∪ free_evars p ∪ free_evars q
      ∪ {[E]}) (maximal_exists_depth_to 0 E ψ))
  (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Σ: Signature
Γ: Theory
p, q: Pattern
E: evar
ψ: Pattern
gpi: ProofInfo
wfp: well_formed p = true
wfq: well_formed q = true
wfC: PC_wf {| pcEvar := E; pcPattern := ψ |}
pile: ProofInfoLe
  (ExGen := list_to_set
              (evar_fresh_seq
                 (free_evars ψ ∪ free_evars p
                  ∪ free_evars q ∪ {[E]})
                 (maximal_exists_depth_to 0 E ψ)),
   SVSubst := list_to_set
                (svar_fresh_seq
                   (free_svars ψ ∪ free_svars p
                    ∪ free_svars q)
                   (maximal_mu_depth_to 0 E ψ)),
   KT := mu_in_evar_path E ψ 0) gpi
Hiff: Γ ⊢i p <---> q using gpi
H: well_formed (p <---> q)
H0: well_formed p
H1: well_formed q
length
  (evar_fresh_seq
     (free_evars ψ ∪ free_evars p ∪ free_evars q
      ∪ {[E]}) (maximal_exists_depth_to 0 E ψ))
≥ maximal_exists_depth_to ?edepth E ψ
Σ: Signature
Γ: Theory
p, q: Pattern
E: evar
ψ: Pattern
gpi: ProofInfo
wfp: well_formed p = true
wfq: well_formed q = true
wfC: PC_wf {| pcEvar := E; pcPattern := ψ |}
pile: ProofInfoLe
  (ExGen := list_to_set
              (evar_fresh_seq
                 (free_evars ψ ∪ free_evars p
                  ∪ free_evars q ∪ {[E]})
                 (maximal_exists_depth_to 0 E ψ)),
   SVSubst := list_to_set
                (svar_fresh_seq
                   (free_svars ψ ∪ free_svars p
                    ∪ free_svars q)
                   (maximal_mu_depth_to 0 E ψ)),
   KT := mu_in_evar_path E ψ 0) gpi
Hiff: Γ ⊢i p <---> q using gpi
H: well_formed (p <---> q)
H0: well_formed p
H1: well_formed q
∀ x : evar,
  x
  ∈ evar_fresh_seq
      (free_evars ψ ∪ free_evars p ∪ free_evars q
       ∪ {[E]}) (maximal_exists_depth_to 0 E ψ)
  → x
    ∈ list_to_set
        (evar_fresh_seq
           (free_evars ψ ∪ free_evars p ∪ free_evars q
            ∪ {[E]}) (maximal_exists_depth_to 0 E ψ))
Σ: Signature
Γ: Theory
p, q: Pattern
E: evar
ψ: Pattern
gpi: ProofInfo
wfp: well_formed p = true
wfq: well_formed q = true
wfC: PC_wf {| pcEvar := E; pcPattern := ψ |}
pile: ProofInfoLe
  (ExGen := list_to_set
              (evar_fresh_seq
                 (free_evars ψ ∪ free_evars p
                  ∪ free_evars q ∪ {[E]})
                 (maximal_exists_depth_to 0 E ψ)),
   SVSubst := list_to_set
                (svar_fresh_seq
                   (free_svars ψ ∪ free_svars p
                    ∪ free_svars q)
                   (maximal_mu_depth_to 0 E ψ)),
   KT := mu_in_evar_path E ψ 0) gpi
Hiff: Γ ⊢i p <---> q using gpi
H: well_formed (p <---> q)
H0: well_formed p
H1: well_formed q
fresh_svars
  (svar_fresh_seq
     (free_svars ψ ∪ free_svars p ∪ free_svars q)
     (maximal_mu_depth_to 0 E ψ))
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Σ: Signature
Γ: Theory
p, q: Pattern
E: evar
ψ: Pattern
gpi: ProofInfo
wfp: well_formed p = true
wfq: well_formed q = true
wfC: PC_wf {| pcEvar := E; pcPattern := ψ |}
pile: ProofInfoLe
  (ExGen := list_to_set
              (evar_fresh_seq
                 (free_evars ψ ∪ free_evars p
                  ∪ free_evars q ∪ {[E]})
                 (maximal_exists_depth_to 0 E ψ)),
   SVSubst := list_to_set
                (svar_fresh_seq
                   (free_svars ψ ∪ free_svars p
                    ∪ free_svars q)
                   (maximal_mu_depth_to 0 E ψ)),
   KT := mu_in_evar_path E ψ 0) gpi
Hiff: Γ ⊢i p <---> q using gpi
H: well_formed (p <---> q)
H0: well_formed p
H1: well_formed q
length
  (svar_fresh_seq
     (free_svars ψ ∪ free_svars p ∪ free_svars q)
     (maximal_mu_depth_to 0 E ψ))
≥ maximal_mu_depth_to ?sdepth E ψ
Σ: Signature
Γ: Theory
p, q: Pattern
E: evar
ψ: Pattern
gpi: ProofInfo
wfp: well_formed p = true
wfq: well_formed q = true
wfC: PC_wf {| pcEvar := E; pcPattern := ψ |}
pile: ProofInfoLe
  (ExGen := list_to_set
              (evar_fresh_seq
                 (free_evars ψ ∪ free_evars p
                  ∪ free_evars q ∪ {[E]})
                 (maximal_exists_depth_to 0 E ψ)),
   SVSubst := list_to_set
                (svar_fresh_seq
                   (free_svars ψ ∪ free_svars p
                    ∪ free_svars q)
                   (maximal_mu_depth_to 0 E ψ)),
   KT := mu_in_evar_path E ψ 0) gpi
Hiff: Γ ⊢i p <---> q using gpi
H: well_formed (p <---> q)
H0: well_formed p
H1: well_formed q
∀ X : svar,
  X
  ∈ svar_fresh_seq
      (free_svars ψ ∪ free_svars p ∪ free_svars q)
      (maximal_mu_depth_to 0 E ψ)
  → X
    ∈ list_to_set
        (svar_fresh_seq
           (free_svars ψ ∪ free_svars p ∪ free_svars q)
           (maximal_mu_depth_to 0 E ψ))
Σ: Signature
Γ: Theory
p, q: Pattern
E: evar
ψ: Pattern
gpi: ProofInfo
wfp: well_formed p = true
wfq: well_formed q = true
wfC: PC_wf {| pcEvar := E; pcPattern := ψ |}
pile: ProofInfoLe
  (ExGen := list_to_set
              (evar_fresh_seq
                 (free_evars ψ ∪ free_evars p
                  ∪ free_evars q ∪ {[E]})
                 (maximal_exists_depth_to 0 E ψ)),
   SVSubst := list_to_set
                (svar_fresh_seq
                   (free_svars ψ ∪ free_svars p
                    ∪ free_svars q)
                   (maximal_mu_depth_to 0 E ψ)),
   KT := mu_in_evar_path E ψ 0) gpi
Hiff: Γ ⊢i p <---> q using gpi
H: well_formed (p <---> q)
H0: well_formed p
H1: well_formed q
ProofInfoLe
  (ExGen := list_to_set
              (evar_fresh_seq
                 (free_evars ψ ∪ free_evars p
                  ∪ free_evars q ∪ {[E]})
                 (maximal_exists_depth_to 0 E ψ)),
   SVSubst := list_to_set
                (svar_fresh_seq
                   (free_svars ψ ∪ free_svars p
                    ∪ free_svars q)
                   (maximal_mu_depth_to 0 E ψ)),
   KT := mu_in_evar_path E ψ ?sdepth) gpi
    {
Σ: Signature
Γ: Theory
p, q: Pattern
E: evar
ψ: Pattern
gpi: ProofInfo
wfp: well_formed p = true
wfq: well_formed q = true
wfC: PC_wf {| pcEvar := E; pcPattern := ψ |}
pile: ProofInfoLe
  (ExGen := list_to_set
              (evar_fresh_seq
                 (free_evars ψ ∪ free_evars p
                  ∪ free_evars q ∪ {[E]})
                 (maximal_exists_depth_to 0 E ψ)),
   SVSubst := list_to_set
                (svar_fresh_seq
                   (free_svars ψ ∪ free_svars p
                    ∪ free_svars q)
                   (maximal_mu_depth_to 0 E ψ)),
   KT := mu_in_evar_path E ψ 0) gpi
Hiff: Γ ⊢i p <---> q using gpi
H: well_formed (p <---> q)
H0: well_formed p
H1: well_formed q
size' ψ ≤ ?sz apply reflexivity. }
Σ: Signature
Γ: Theory
p, q: Pattern
E: evar
ψ: Pattern
gpi: ProofInfo
wfp: well_formed p = true
wfq: well_formed q = true
wfC: PC_wf {| pcEvar := E; pcPattern := ψ |}
pile: ProofInfoLe
  (ExGen := list_to_set
              (evar_fresh_seq
                 (free_evars ψ ∪ free_evars p
                  ∪ free_evars q ∪ {[E]})
                 (maximal_exists_depth_to 0 E ψ)),
   SVSubst := list_to_set
                (svar_fresh_seq
                   (free_svars ψ ∪ free_svars p
                    ∪ free_svars q)
                   (maximal_mu_depth_to 0 E ψ)),
   KT := mu_in_evar_path E ψ 0) gpi
Hiff: Γ ⊢i p <---> q using gpi
H: well_formed (p <---> q)
H0: well_formed p
H1: well_formed q
fresh_evars
  (evar_fresh_seq
     (free_evars ψ ∪ free_evars p ∪ free_evars q
      ∪ {[E]}) (maximal_exists_depth_to 0 E ψ))
  (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Σ: Signature
Γ: Theory
p, q: Pattern
E: evar
ψ: Pattern
gpi: ProofInfo
wfp: well_formed p = true
wfq: well_formed q = true
wfC: PC_wf {| pcEvar := E; pcPattern := ψ |}
pile: ProofInfoLe
  (ExGen := list_to_set
              (evar_fresh_seq
                 (free_evars ψ ∪ free_evars p
                  ∪ free_evars q ∪ {[E]})
                 (maximal_exists_depth_to 0 E ψ)),
   SVSubst := list_to_set
                (svar_fresh_seq
                   (free_svars ψ ∪ free_svars p
                    ∪ free_svars q)
                   (maximal_mu_depth_to 0 E ψ)),
   KT := mu_in_evar_path E ψ 0) gpi
Hiff: Γ ⊢i p <---> q using gpi
H: well_formed (p <---> q)
H0: well_formed p
H1: well_formed q
length
  (evar_fresh_seq
     (free_evars ψ ∪ free_evars p ∪ free_evars q
      ∪ {[E]}) (maximal_exists_depth_to 0 E ψ))
≥ maximal_exists_depth_to ?edepth E ψ
Σ: Signature
Γ: Theory
p, q: Pattern
E: evar
ψ: Pattern
gpi: ProofInfo
wfp: well_formed p = true
wfq: well_formed q = true
wfC: PC_wf {| pcEvar := E; pcPattern := ψ |}
pile: ProofInfoLe
  (ExGen := list_to_set
              (evar_fresh_seq
                 (free_evars ψ ∪ free_evars p
                  ∪ free_evars q ∪ {[E]})
                 (maximal_exists_depth_to 0 E ψ)),
   SVSubst := list_to_set
                (svar_fresh_seq
                   (free_svars ψ ∪ free_svars p
                    ∪ free_svars q)
                   (maximal_mu_depth_to 0 E ψ)),
   KT := mu_in_evar_path E ψ 0) gpi
Hiff: Γ ⊢i p <---> q using gpi
H: well_formed (p <---> q)
H0: well_formed p
H1: well_formed q
∀ x : evar,
  x
  ∈ evar_fresh_seq
      (free_evars ψ ∪ free_evars p ∪ free_evars q
       ∪ {[E]}) (maximal_exists_depth_to 0 E ψ)
  → x
    ∈ list_to_set
        (evar_fresh_seq
           (free_evars ψ ∪ free_evars p ∪ free_evars q
            ∪ {[E]}) (maximal_exists_depth_to 0 E ψ))
Σ: Signature
Γ: Theory
p, q: Pattern
E: evar
ψ: Pattern
gpi: ProofInfo
wfp: well_formed p = true
wfq: well_formed q = true
wfC: PC_wf {| pcEvar := E; pcPattern := ψ |}
pile: ProofInfoLe
  (ExGen := list_to_set
              (evar_fresh_seq
                 (free_evars ψ ∪ free_evars p
                  ∪ free_evars q ∪ {[E]})
                 (maximal_exists_depth_to 0 E ψ)),
   SVSubst := list_to_set
                (svar_fresh_seq
                   (free_svars ψ ∪ free_svars p
                    ∪ free_svars q)
                   (maximal_mu_depth_to 0 E ψ)),
   KT := mu_in_evar_path E ψ 0) gpi
Hiff: Γ ⊢i p <---> q using gpi
H: well_formed (p <---> q)
H0: well_formed p
H1: well_formed q
fresh_svars
  (svar_fresh_seq
     (free_svars ψ ∪ free_svars p ∪ free_svars q)
     (maximal_mu_depth_to 0 E ψ))
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Σ: Signature
Γ: Theory
p, q: Pattern
E: evar
ψ: Pattern
gpi: ProofInfo
wfp: well_formed p = true
wfq: well_formed q = true
wfC: PC_wf {| pcEvar := E; pcPattern := ψ |}
pile: ProofInfoLe
  (ExGen := list_to_set
              (evar_fresh_seq
                 (free_evars ψ ∪ free_evars p
                  ∪ free_evars q ∪ {[E]})
                 (maximal_exists_depth_to 0 E ψ)),
   SVSubst := list_to_set
                (svar_fresh_seq
                   (free_svars ψ ∪ free_svars p
                    ∪ free_svars q)
                   (maximal_mu_depth_to 0 E ψ)),
   KT := mu_in_evar_path E ψ 0) gpi
Hiff: Γ ⊢i p <---> q using gpi
H: well_formed (p <---> q)
H0: well_formed p
H1: well_formed q
length
  (svar_fresh_seq
     (free_svars ψ ∪ free_svars p ∪ free_svars q)
     (maximal_mu_depth_to 0 E ψ))
≥ maximal_mu_depth_to ?sdepth E ψ
Σ: Signature
Γ: Theory
p, q: Pattern
E: evar
ψ: Pattern
gpi: ProofInfo
wfp: well_formed p = true
wfq: well_formed q = true
wfC: PC_wf {| pcEvar := E; pcPattern := ψ |}
pile: ProofInfoLe
  (ExGen := list_to_set
              (evar_fresh_seq
                 (free_evars ψ ∪ free_evars p
                  ∪ free_evars q ∪ {[E]})
                 (maximal_exists_depth_to 0 E ψ)),
   SVSubst := list_to_set
                (svar_fresh_seq
                   (free_svars ψ ∪ free_svars p
                    ∪ free_svars q)
                   (maximal_mu_depth_to 0 E ψ)),
   KT := mu_in_evar_path E ψ 0) gpi
Hiff: Γ ⊢i p <---> q using gpi
H: well_formed (p <---> q)
H0: well_formed p
H1: well_formed q
∀ X : svar,
  X
  ∈ svar_fresh_seq
      (free_svars ψ ∪ free_svars p ∪ free_svars q)
      (maximal_mu_depth_to 0 E ψ)
  → X
    ∈ list_to_set
        (svar_fresh_seq
           (free_svars ψ ∪ free_svars p ∪ free_svars q)
           (maximal_mu_depth_to 0 E ψ))
Σ: Signature
Γ: Theory
p, q: Pattern
E: evar
ψ: Pattern
gpi: ProofInfo
wfp: well_formed p = true
wfq: well_formed q = true
wfC: PC_wf {| pcEvar := E; pcPattern := ψ |}
pile: ProofInfoLe
  (ExGen := list_to_set
              (evar_fresh_seq
                 (free_evars ψ ∪ free_evars p
                  ∪ free_evars q ∪ {[E]})
                 (maximal_exists_depth_to 0 E ψ)),
   SVSubst := list_to_set
                (svar_fresh_seq
                   (free_svars ψ ∪ free_svars p
                    ∪ free_svars q)
                   (maximal_mu_depth_to 0 E ψ)),
   KT := mu_in_evar_path E ψ 0) gpi
Hiff: Γ ⊢i p <---> q using gpi
H: well_formed (p <---> q)
H0: well_formed p
H1: well_formed q
ProofInfoLe
  (ExGen := list_to_set
              (evar_fresh_seq
                 (free_evars ψ ∪ free_evars p
                  ∪ free_evars q ∪ {[E]})
                 (maximal_exists_depth_to 0 E ψ)),
   SVSubst := list_to_set
                (svar_fresh_seq
                   (free_svars ψ ∪ free_svars p
                    ∪ free_svars q)
                   (maximal_mu_depth_to 0 E ψ)),
   KT := mu_in_evar_path E ψ ?sdepth) gpi
    {
Σ: Signature
Γ: Theory
p, q: Pattern
E: evar
ψ: Pattern
gpi: ProofInfo
wfp: well_formed p = true
wfq: well_formed q = true
wfC: PC_wf {| pcEvar := E; pcPattern := ψ |}
pile: ProofInfoLe
  (ExGen := list_to_set
              (evar_fresh_seq
                 (free_evars ψ ∪ free_evars p
                  ∪ free_evars q ∪ {[E]})
                 (maximal_exists_depth_to 0 E ψ)),
   SVSubst := list_to_set
                (svar_fresh_seq
                   (free_svars ψ ∪ free_svars p
                    ∪ free_svars q)
                   (maximal_mu_depth_to 0 E ψ)),
   KT := mu_in_evar_path E ψ 0) gpi
Hiff: Γ ⊢i p <---> q using gpi
H: well_formed (p <---> q)
H0: well_formed p
H1: well_formed q
fresh_evars
  (evar_fresh_seq
     (free_evars ψ ∪ free_evars p ∪ free_evars q
      ∪ {[E]}) (maximal_exists_depth_to 0 E ψ))
  (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) abstract (apply evar_fresh_seq_correct). }
Σ: Signature
Γ: Theory
p, q: Pattern
E: evar
ψ: Pattern
gpi: ProofInfo
wfp: well_formed p = true
wfq: well_formed q = true
wfC: PC_wf {| pcEvar := E; pcPattern := ψ |}
pile: ProofInfoLe
  (ExGen := list_to_set
              (evar_fresh_seq
                 (free_evars ψ ∪ free_evars p
                  ∪ free_evars q ∪ {[E]})
                 (maximal_exists_depth_to 0 E ψ)),
   SVSubst := list_to_set
                (svar_fresh_seq
                   (free_svars ψ ∪ free_svars p
                    ∪ free_svars q)
                   (maximal_mu_depth_to 0 E ψ)),
   KT := mu_in_evar_path E ψ 0) gpi
Hiff: Γ ⊢i p <---> q using gpi
H: well_formed (p <---> q)
H0: well_formed p
H1: well_formed q
length
  (evar_fresh_seq
     (free_evars ψ ∪ free_evars p ∪ free_evars q
      ∪ {[E]}) (maximal_exists_depth_to 0 E ψ))
≥ maximal_exists_depth_to ?edepth E ψ
Σ: Signature
Γ: Theory
p, q: Pattern
E: evar
ψ: Pattern
gpi: ProofInfo
wfp: well_formed p = true
wfq: well_formed q = true
wfC: PC_wf {| pcEvar := E; pcPattern := ψ |}
pile: ProofInfoLe
  (ExGen := list_to_set
              (evar_fresh_seq
                 (free_evars ψ ∪ free_evars p
                  ∪ free_evars q ∪ {[E]})
                 (maximal_exists_depth_to 0 E ψ)),
   SVSubst := list_to_set
                (svar_fresh_seq
                   (free_svars ψ ∪ free_svars p
                    ∪ free_svars q)
                   (maximal_mu_depth_to 0 E ψ)),
   KT := mu_in_evar_path E ψ 0) gpi
Hiff: Γ ⊢i p <---> q using gpi
H: well_formed (p <---> q)
H0: well_formed p
H1: well_formed q
∀ x : evar,
  x
  ∈ evar_fresh_seq
      (free_evars ψ ∪ free_evars p ∪ free_evars q
       ∪ {[E]}) (maximal_exists_depth_to 0 E ψ)
  → x
    ∈ list_to_set
        (evar_fresh_seq
           (free_evars ψ ∪ free_evars p ∪ free_evars q
            ∪ {[E]}) (maximal_exists_depth_to 0 E ψ))
Σ: Signature
Γ: Theory
p, q: Pattern
E: evar
ψ: Pattern
gpi: ProofInfo
wfp: well_formed p = true
wfq: well_formed q = true
wfC: PC_wf {| pcEvar := E; pcPattern := ψ |}
pile: ProofInfoLe
  (ExGen := list_to_set
              (evar_fresh_seq
                 (free_evars ψ ∪ free_evars p
                  ∪ free_evars q ∪ {[E]})
                 (maximal_exists_depth_to 0 E ψ)),
   SVSubst := list_to_set
                (svar_fresh_seq
                   (free_svars ψ ∪ free_svars p
                    ∪ free_svars q)
                   (maximal_mu_depth_to 0 E ψ)),
   KT := mu_in_evar_path E ψ 0) gpi
Hiff: Γ ⊢i p <---> q using gpi
H: well_formed (p <---> q)
H0: well_formed p
H1: well_formed q
fresh_svars
  (svar_fresh_seq
     (free_svars ψ ∪ free_svars p ∪ free_svars q)
     (maximal_mu_depth_to 0 E ψ))
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Σ: Signature
Γ: Theory
p, q: Pattern
E: evar
ψ: Pattern
gpi: ProofInfo
wfp: well_formed p = true
wfq: well_formed q = true
wfC: PC_wf {| pcEvar := E; pcPattern := ψ |}
pile: ProofInfoLe
  (ExGen := list_to_set
              (evar_fresh_seq
                 (free_evars ψ ∪ free_evars p
                  ∪ free_evars q ∪ {[E]})
                 (maximal_exists_depth_to 0 E ψ)),
   SVSubst := list_to_set
                (svar_fresh_seq
                   (free_svars ψ ∪ free_svars p
                    ∪ free_svars q)
                   (maximal_mu_depth_to 0 E ψ)),
   KT := mu_in_evar_path E ψ 0) gpi
Hiff: Γ ⊢i p <---> q using gpi
H: well_formed (p <---> q)
H0: well_formed p
H1: well_formed q
length
  (svar_fresh_seq
     (free_svars ψ ∪ free_svars p ∪ free_svars q)
     (maximal_mu_depth_to 0 E ψ))
≥ maximal_mu_depth_to ?sdepth E ψ
Σ: Signature
Γ: Theory
p, q: Pattern
E: evar
ψ: Pattern
gpi: ProofInfo
wfp: well_formed p = true
wfq: well_formed q = true
wfC: PC_wf {| pcEvar := E; pcPattern := ψ |}
pile: ProofInfoLe
  (ExGen := list_to_set
              (evar_fresh_seq
                 (free_evars ψ ∪ free_evars p
                  ∪ free_evars q ∪ {[E]})
                 (maximal_exists_depth_to 0 E ψ)),
   SVSubst := list_to_set
                (svar_fresh_seq
                   (free_svars ψ ∪ free_svars p
                    ∪ free_svars q)
                   (maximal_mu_depth_to 0 E ψ)),
   KT := mu_in_evar_path E ψ 0) gpi
Hiff: Γ ⊢i p <---> q using gpi
H: well_formed (p <---> q)
H0: well_formed p
H1: well_formed q
∀ X : svar,
  X
  ∈ svar_fresh_seq
      (free_svars ψ ∪ free_svars p ∪ free_svars q)
      (maximal_mu_depth_to 0 E ψ)
  → X
    ∈ list_to_set
        (svar_fresh_seq
           (free_svars ψ ∪ free_svars p ∪ free_svars q)
           (maximal_mu_depth_to 0 E ψ))
Σ: Signature
Γ: Theory
p, q: Pattern
E: evar
ψ: Pattern
gpi: ProofInfo
wfp: well_formed p = true
wfq: well_formed q = true
wfC: PC_wf {| pcEvar := E; pcPattern := ψ |}
pile: ProofInfoLe
  (ExGen := list_to_set
              (evar_fresh_seq
                 (free_evars ψ ∪ free_evars p
                  ∪ free_evars q ∪ {[E]})
                 (maximal_exists_depth_to 0 E ψ)),
   SVSubst := list_to_set
                (svar_fresh_seq
                   (free_svars ψ ∪ free_svars p
                    ∪ free_svars q)
                   (maximal_mu_depth_to 0 E ψ)),
   KT := mu_in_evar_path E ψ 0) gpi
Hiff: Γ ⊢i p <---> q using gpi
H: well_formed (p <---> q)
H0: well_formed p
H1: well_formed q
ProofInfoLe
  (ExGen := list_to_set
              (evar_fresh_seq
                 (free_evars ψ ∪ free_evars p
                  ∪ free_evars q ∪ {[E]})
                 (maximal_exists_depth_to 0 E ψ)),
   SVSubst := list_to_set
                (svar_fresh_seq
                   (free_svars ψ ∪ free_svars p
                    ∪ free_svars q)
                   (maximal_mu_depth_to 0 E ψ)),
   KT := mu_in_evar_path E ψ ?sdepth) gpi
    {
Σ: Signature
Γ: Theory
p, q: Pattern
E: evar
ψ: Pattern
gpi: ProofInfo
wfp: well_formed p = true
wfq: well_formed q = true
wfC: PC_wf {| pcEvar := E; pcPattern := ψ |}
pile: ProofInfoLe
  (ExGen := list_to_set
              (evar_fresh_seq
                 (free_evars ψ ∪ free_evars p
                  ∪ free_evars q ∪ {[E]})
                 (maximal_exists_depth_to 0 E ψ)),
   SVSubst := list_to_set
                (svar_fresh_seq
                   (free_svars ψ ∪ free_svars p
                    ∪ free_svars q)
                   (maximal_mu_depth_to 0 E ψ)),
   KT := mu_in_evar_path E ψ 0) gpi
Hiff: Γ ⊢i p <---> q using gpi
H: well_formed (p <---> q)
H0: well_formed p
H1: well_formed q
length
  (evar_fresh_seq
     (free_evars ψ ∪ free_evars p ∪ free_evars q
      ∪ {[E]}) (maximal_exists_depth_to 0 E ψ))
≥ maximal_exists_depth_to ?edepth E ψ instantiate (1 := 0); abstract (pose proof (evar_fresh_seq_length (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) (maximal_exists_depth_to 0 E ψ)); lia). }
Σ: Signature
Γ: Theory
p, q: Pattern
E: evar
ψ: Pattern
gpi: ProofInfo
wfp: well_formed p = true
wfq: well_formed q = true
wfC: PC_wf {| pcEvar := E; pcPattern := ψ |}
pile: ProofInfoLe
  (ExGen := list_to_set
              (evar_fresh_seq
                 (free_evars ψ ∪ free_evars p
                  ∪ free_evars q ∪ {[E]})
                 (maximal_exists_depth_to 0 E ψ)),
   SVSubst := list_to_set
                (svar_fresh_seq
                   (free_svars ψ ∪ free_svars p
                    ∪ free_svars q)
                   (maximal_mu_depth_to 0 E ψ)),
   KT := mu_in_evar_path E ψ 0) gpi
Hiff: Γ ⊢i p <---> q using gpi
H: well_formed (p <---> q)
H0: well_formed p
H1: well_formed q
∀ x : evar,
  x
  ∈ evar_fresh_seq
      (free_evars ψ ∪ free_evars p ∪ free_evars q
       ∪ {[E]}) (maximal_exists_depth_to 0 E ψ)
  → x
    ∈ list_to_set
        (evar_fresh_seq
           (free_evars ψ ∪ free_evars p ∪ free_evars q
            ∪ {[E]}) (maximal_exists_depth_to 0 E ψ))
Σ: Signature
Γ: Theory
p, q: Pattern
E: evar
ψ: Pattern
gpi: ProofInfo
wfp: well_formed p = true
wfq: well_formed q = true
wfC: PC_wf {| pcEvar := E; pcPattern := ψ |}
pile: ProofInfoLe
  (ExGen := list_to_set
              (evar_fresh_seq
                 (free_evars ψ ∪ free_evars p
                  ∪ free_evars q ∪ {[E]})
                 (maximal_exists_depth_to 0 E ψ)),
   SVSubst := list_to_set
                (svar_fresh_seq
                   (free_svars ψ ∪ free_svars p
                    ∪ free_svars q)
                   (maximal_mu_depth_to 0 E ψ)),
   KT := mu_in_evar_path E ψ 0) gpi
Hiff: Γ ⊢i p <---> q using gpi
H: well_formed (p <---> q)
H0: well_formed p
H1: well_formed q
fresh_svars
  (svar_fresh_seq
     (free_svars ψ ∪ free_svars p ∪ free_svars q)
     (maximal_mu_depth_to 0 E ψ))
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Σ: Signature
Γ: Theory
p, q: Pattern
E: evar
ψ: Pattern
gpi: ProofInfo
wfp: well_formed p = true
wfq: well_formed q = true
wfC: PC_wf {| pcEvar := E; pcPattern := ψ |}
pile: ProofInfoLe
  (ExGen := list_to_set
              (evar_fresh_seq
                 (free_evars ψ ∪ free_evars p
                  ∪ free_evars q ∪ {[E]})
                 (maximal_exists_depth_to 0 E ψ)),
   SVSubst := list_to_set
                (svar_fresh_seq
                   (free_svars ψ ∪ free_svars p
                    ∪ free_svars q)
                   (maximal_mu_depth_to 0 E ψ)),
   KT := mu_in_evar_path E ψ 0) gpi
Hiff: Γ ⊢i p <---> q using gpi
H: well_formed (p <---> q)
H0: well_formed p
H1: well_formed q
length
  (svar_fresh_seq
     (free_svars ψ ∪ free_svars p ∪ free_svars q)
     (maximal_mu_depth_to 0 E ψ))
≥ maximal_mu_depth_to ?sdepth E ψ
Σ: Signature
Γ: Theory
p, q: Pattern
E: evar
ψ: Pattern
gpi: ProofInfo
wfp: well_formed p = true
wfq: well_formed q = true
wfC: PC_wf {| pcEvar := E; pcPattern := ψ |}
pile: ProofInfoLe
  (ExGen := list_to_set
              (evar_fresh_seq
                 (free_evars ψ ∪ free_evars p
                  ∪ free_evars q ∪ {[E]})
                 (maximal_exists_depth_to 0 E ψ)),
   SVSubst := list_to_set
                (svar_fresh_seq
                   (free_svars ψ ∪ free_svars p
                    ∪ free_svars q)
                   (maximal_mu_depth_to 0 E ψ)),
   KT := mu_in_evar_path E ψ 0) gpi
Hiff: Γ ⊢i p <---> q using gpi
H: well_formed (p <---> q)
H0: well_formed p
H1: well_formed q
∀ X : svar,
  X
  ∈ svar_fresh_seq
      (free_svars ψ ∪ free_svars p ∪ free_svars q)
      (maximal_mu_depth_to 0 E ψ)
  → X
    ∈ list_to_set
        (svar_fresh_seq
           (free_svars ψ ∪ free_svars p ∪ free_svars q)
           (maximal_mu_depth_to 0 E ψ))
Σ: Signature
Γ: Theory
p, q: Pattern
E: evar
ψ: Pattern
gpi: ProofInfo
wfp: well_formed p = true
wfq: well_formed q = true
wfC: PC_wf {| pcEvar := E; pcPattern := ψ |}
pile: ProofInfoLe
  (ExGen := list_to_set
              (evar_fresh_seq
                 (free_evars ψ ∪ free_evars p
                  ∪ free_evars q ∪ {[E]})
                 (maximal_exists_depth_to 0 E ψ)),
   SVSubst := list_to_set
                (svar_fresh_seq
                   (free_svars ψ ∪ free_svars p
                    ∪ free_svars q)
                   (maximal_mu_depth_to 0 E ψ)),
   KT := mu_in_evar_path E ψ 0) gpi
Hiff: Γ ⊢i p <---> q using gpi
H: well_formed (p <---> q)
H0: well_formed p
H1: well_formed q
ProofInfoLe
  (ExGen := list_to_set
              (evar_fresh_seq
                 (free_evars ψ ∪ free_evars p
                  ∪ free_evars q ∪ {[E]})
                 (maximal_exists_depth_to 0 E ψ)),
   SVSubst := list_to_set
                (svar_fresh_seq
                   (free_svars ψ ∪ free_svars p
                    ∪ free_svars q)
                   (maximal_mu_depth_to 0 E ψ)),
   KT := mu_in_evar_path E ψ ?sdepth) gpi
    {
Σ: Signature
Γ: Theory
p, q: Pattern
E: evar
ψ: Pattern
gpi: ProofInfo
wfp: well_formed p = true
wfq: well_formed q = true
wfC: PC_wf {| pcEvar := E; pcPattern := ψ |}
pile: ProofInfoLe
  (ExGen := list_to_set
              (evar_fresh_seq
                 (free_evars ψ ∪ free_evars p
                  ∪ free_evars q ∪ {[E]})
                 (maximal_exists_depth_to 0 E ψ)),
   SVSubst := list_to_set
                (svar_fresh_seq
                   (free_svars ψ ∪ free_svars p
                    ∪ free_svars q)
                   (maximal_mu_depth_to 0 E ψ)),
   KT := mu_in_evar_path E ψ 0) gpi
Hiff: Γ ⊢i p <---> q using gpi
H: well_formed (p <---> q)
H0: well_formed p
H1: well_formed q
∀ x : evar,
  x
  ∈ evar_fresh_seq
      (free_evars ψ ∪ free_evars p ∪ free_evars q
       ∪ {[E]}) (maximal_exists_depth_to 0 E ψ)
  → x
    ∈ list_to_set
        (evar_fresh_seq
           (free_evars ψ ∪ free_evars p ∪ free_evars q
            ∪ {[E]}) (maximal_exists_depth_to 0 E ψ)) intros.
Σ: Signature
Γ: Theory
p, q: Pattern
E: evar
ψ: Pattern
gpi: ProofInfo
wfp: well_formed p = true
wfq: well_formed q = true
wfC: PC_wf {| pcEvar := E; pcPattern := ψ |}
pile: ProofInfoLe
  (ExGen := list_to_set
              (evar_fresh_seq
                 (free_evars ψ ∪ free_evars p
                  ∪ free_evars q ∪ {[E]})
                 (maximal_exists_depth_to 0 E ψ)),
   SVSubst := list_to_set
                (svar_fresh_seq
                   (free_svars ψ ∪ free_svars p
                    ∪ free_svars q)
                   (maximal_mu_depth_to 0 E ψ)),
   KT := mu_in_evar_path E ψ 0) gpi
Hiff: Γ ⊢i p <---> q using gpi
H: well_formed (p <---> q)
H0: well_formed p
H1: well_formed q
x: evar
H2: x
∈ evar_fresh_seq
    (free_evars ψ ∪ free_evars p ∪ free_evars q
     ∪ {[E]}) (maximal_exists_depth_to 0 E ψ)
x
∈ list_to_set
    (evar_fresh_seq
       (free_evars ψ ∪ free_evars p ∪ free_evars q
        ∪ {[E]}) (maximal_exists_depth_to 0 E ψ)) set_solver. }
Σ: Signature
Γ: Theory
p, q: Pattern
E: evar
ψ: Pattern
gpi: ProofInfo
wfp: well_formed p = true
wfq: well_formed q = true
wfC: PC_wf {| pcEvar := E; pcPattern := ψ |}
pile: ProofInfoLe
  (ExGen := list_to_set
              (evar_fresh_seq
                 (free_evars ψ ∪ free_evars p
                  ∪ free_evars q ∪ {[E]})
                 (maximal_exists_depth_to 0 E ψ)),
   SVSubst := list_to_set
                (svar_fresh_seq
                   (free_svars ψ ∪ free_svars p
                    ∪ free_svars q)
                   (maximal_mu_depth_to 0 E ψ)),
   KT := mu_in_evar_path E ψ 0) gpi
Hiff: Γ ⊢i p <---> q using gpi
H: well_formed (p <---> q)
H0: well_formed p
H1: well_formed q
fresh_svars
  (svar_fresh_seq
     (free_svars ψ ∪ free_svars p ∪ free_svars q)
     (maximal_mu_depth_to 0 E ψ))
  (free_svars ψ ∪ free_svars p ∪ free_svars q)
Σ: Signature
Γ: Theory
p, q: Pattern
E: evar
ψ: Pattern
gpi: ProofInfo
wfp: well_formed p = true
wfq: well_formed q = true
wfC: PC_wf {| pcEvar := E; pcPattern := ψ |}
pile: ProofInfoLe
  (ExGen := list_to_set
              (evar_fresh_seq
                 (free_evars ψ ∪ free_evars p
                  ∪ free_evars q ∪ {[E]})
                 (maximal_exists_depth_to 0 E ψ)),
   SVSubst := list_to_set
                (svar_fresh_seq
                   (free_svars ψ ∪ free_svars p
                    ∪ free_svars q)
                   (maximal_mu_depth_to 0 E ψ)),
   KT := mu_in_evar_path E ψ 0) gpi
Hiff: Γ ⊢i p <---> q using gpi
H: well_formed (p <---> q)
H0: well_formed p
H1: well_formed q
length
  (svar_fresh_seq
     (free_svars ψ ∪ free_svars p ∪ free_svars q)
     (maximal_mu_depth_to 0 E ψ))
≥ maximal_mu_depth_to ?sdepth E ψ
Σ: Signature
Γ: Theory
p, q: Pattern
E: evar
ψ: Pattern
gpi: ProofInfo
wfp: well_formed p = true
wfq: well_formed q = true
wfC: PC_wf {| pcEvar := E; pcPattern := ψ |}
pile: ProofInfoLe
  (ExGen := list_to_set
              (evar_fresh_seq
                 (free_evars ψ ∪ free_evars p
                  ∪ free_evars q ∪ {[E]})
                 (maximal_exists_depth_to 0 E ψ)),
   SVSubst := list_to_set
                (svar_fresh_seq
                   (free_svars ψ ∪ free_svars p
                    ∪ free_svars q)
                   (maximal_mu_depth_to 0 E ψ)),
   KT := mu_in_evar_path E ψ 0) gpi
Hiff: Γ ⊢i p <---> q using gpi
H: well_formed (p <---> q)
H0: well_formed p
H1: well_formed q
∀ X : svar,
  X
  ∈ svar_fresh_seq
      (free_svars ψ ∪ free_svars p ∪ free_svars q)
      (maximal_mu_depth_to 0 E ψ)
  → X
    ∈ list_to_set
        (svar_fresh_seq
           (free_svars ψ ∪ free_svars p ∪ free_svars q)
           (maximal_mu_depth_to 0 E ψ))
Σ: Signature
Γ: Theory
p, q: Pattern
E: evar
ψ: Pattern
gpi: ProofInfo
wfp: well_formed p = true
wfq: well_formed q = true
wfC: PC_wf {| pcEvar := E; pcPattern := ψ |}
pile: ProofInfoLe
  (ExGen := list_to_set
              (evar_fresh_seq
                 (free_evars ψ ∪ free_evars p
                  ∪ free_evars q ∪ {[E]})
                 (maximal_exists_depth_to 0 E ψ)),
   SVSubst := list_to_set
                (svar_fresh_seq
                   (free_svars ψ ∪ free_svars p
                    ∪ free_svars q)
                   (maximal_mu_depth_to 0 E ψ)),
   KT := mu_in_evar_path E ψ 0) gpi
Hiff: Γ ⊢i p <---> q using gpi
H: well_formed (p <---> q)
H0: well_formed p
H1: well_formed q
ProofInfoLe
  (ExGen := list_to_set
              (evar_fresh_seq
                 (free_evars ψ ∪ free_evars p
                  ∪ free_evars q ∪ {[E]})
                 (maximal_exists_depth_to 0 E ψ)),
   SVSubst := list_to_set
                (svar_fresh_seq
                   (free_svars ψ ∪ free_svars p
                    ∪ free_svars q)
                   (maximal_mu_depth_to 0 E ψ)),
   KT := mu_in_evar_path E ψ ?sdepth) gpi
    {
Σ: Signature
Γ: Theory
p, q: Pattern
E: evar
ψ: Pattern
gpi: ProofInfo
wfp: well_formed p = true
wfq: well_formed q = true
wfC: PC_wf {| pcEvar := E; pcPattern := ψ |}
pile: ProofInfoLe
  (ExGen := list_to_set
              (evar_fresh_seq
                 (free_evars ψ ∪ free_evars p
                  ∪ free_evars q ∪ {[E]})
                 (maximal_exists_depth_to 0 E ψ)),
   SVSubst := list_to_set
                (svar_fresh_seq
                   (free_svars ψ ∪ free_svars p
                    ∪ free_svars q)
                   (maximal_mu_depth_to 0 E ψ)),
   KT := mu_in_evar_path E ψ 0) gpi
Hiff: Γ ⊢i p <---> q using gpi
H: well_formed (p <---> q)
H0: well_formed p
H1: well_formed q
fresh_svars
  (svar_fresh_seq
     (free_svars ψ ∪ free_svars p ∪ free_svars q)
     (maximal_mu_depth_to 0 E ψ))
  (free_svars ψ ∪ free_svars p ∪ free_svars q) abstract (apply svar_fresh_seq_correct). }
Σ: Signature
Γ: Theory
p, q: Pattern
E: evar
ψ: Pattern
gpi: ProofInfo
wfp: well_formed p = true
wfq: well_formed q = true
wfC: PC_wf {| pcEvar := E; pcPattern := ψ |}
pile: ProofInfoLe
  (ExGen := list_to_set
              (evar_fresh_seq
                 (free_evars ψ ∪ free_evars p
                  ∪ free_evars q ∪ {[E]})
                 (maximal_exists_depth_to 0 E ψ)),
   SVSubst := list_to_set
                (svar_fresh_seq
                   (free_svars ψ ∪ free_svars p
                    ∪ free_svars q)
                   (maximal_mu_depth_to 0 E ψ)),
   KT := mu_in_evar_path E ψ 0) gpi
Hiff: Γ ⊢i p <---> q using gpi
H: well_formed (p <---> q)
H0: well_formed p
H1: well_formed q
length
  (svar_fresh_seq
     (free_svars ψ ∪ free_svars p ∪ free_svars q)
     (maximal_mu_depth_to 0 E ψ))
≥ maximal_mu_depth_to ?sdepth E ψ
Σ: Signature
Γ: Theory
p, q: Pattern
E: evar
ψ: Pattern
gpi: ProofInfo
wfp: well_formed p = true
wfq: well_formed q = true
wfC: PC_wf {| pcEvar := E; pcPattern := ψ |}
pile: ProofInfoLe
  (ExGen := list_to_set
              (evar_fresh_seq
                 (free_evars ψ ∪ free_evars p
                  ∪ free_evars q ∪ {[E]})
                 (maximal_exists_depth_to 0 E ψ)),
   SVSubst := list_to_set
                (svar_fresh_seq
                   (free_svars ψ ∪ free_svars p
                    ∪ free_svars q)
                   (maximal_mu_depth_to 0 E ψ)),
   KT := mu_in_evar_path E ψ 0) gpi
Hiff: Γ ⊢i p <---> q using gpi
H: well_formed (p <---> q)
H0: well_formed p
H1: well_formed q
∀ X : svar,
  X
  ∈ svar_fresh_seq
      (free_svars ψ ∪ free_svars p ∪ free_svars q)
      (maximal_mu_depth_to 0 E ψ)
  → X
    ∈ list_to_set
        (svar_fresh_seq
           (free_svars ψ ∪ free_svars p ∪ free_svars q)
           (maximal_mu_depth_to 0 E ψ))
Σ: Signature
Γ: Theory
p, q: Pattern
E: evar
ψ: Pattern
gpi: ProofInfo
wfp: well_formed p = true
wfq: well_formed q = true
wfC: PC_wf {| pcEvar := E; pcPattern := ψ |}
pile: ProofInfoLe
  (ExGen := list_to_set
              (evar_fresh_seq
                 (free_evars ψ ∪ free_evars p
                  ∪ free_evars q ∪ {[E]})
                 (maximal_exists_depth_to 0 E ψ)),
   SVSubst := list_to_set
                (svar_fresh_seq
                   (free_svars ψ ∪ free_svars p
                    ∪ free_svars q)
                   (maximal_mu_depth_to 0 E ψ)),
   KT := mu_in_evar_path E ψ 0) gpi
Hiff: Γ ⊢i p <---> q using gpi
H: well_formed (p <---> q)
H0: well_formed p
H1: well_formed q
ProofInfoLe
  (ExGen := list_to_set
              (evar_fresh_seq
                 (free_evars ψ ∪ free_evars p
                  ∪ free_evars q ∪ {[E]})
                 (maximal_exists_depth_to 0 E ψ)),
   SVSubst := list_to_set
                (svar_fresh_seq
                   (free_svars ψ ∪ free_svars p
                    ∪ free_svars q)
                   (maximal_mu_depth_to 0 E ψ)),
   KT := mu_in_evar_path E ψ ?sdepth) gpi
    {
Σ: Signature
Γ: Theory
p, q: Pattern
E: evar
ψ: Pattern
gpi: ProofInfo
wfp: well_formed p = true
wfq: well_formed q = true
wfC: PC_wf {| pcEvar := E; pcPattern := ψ |}
pile: ProofInfoLe
  (ExGen := list_to_set
              (evar_fresh_seq
                 (free_evars ψ ∪ free_evars p
                  ∪ free_evars q ∪ {[E]})
                 (maximal_exists_depth_to 0 E ψ)),
   SVSubst := list_to_set
                (svar_fresh_seq
                   (free_svars ψ ∪ free_svars p
                    ∪ free_svars q)
                   (maximal_mu_depth_to 0 E ψ)),
   KT := mu_in_evar_path E ψ 0) gpi
Hiff: Γ ⊢i p <---> q using gpi
H: well_formed (p <---> q)
H0: well_formed p
H1: well_formed q
length
  (svar_fresh_seq
     (free_svars ψ ∪ free_svars p ∪ free_svars q)
     (maximal_mu_depth_to 0 E ψ))
≥ maximal_mu_depth_to ?sdepth E ψ instantiate (1 := 0); abstract (pose proof (svar_fresh_seq_length (free_svars ψ ∪ free_svars p ∪ free_svars q) (maximal_mu_depth_to 0 E ψ)); lia). }
Σ: Signature
Γ: Theory
p, q: Pattern
E: evar
ψ: Pattern
gpi: ProofInfo
wfp: well_formed p = true
wfq: well_formed q = true
wfC: PC_wf {| pcEvar := E; pcPattern := ψ |}
pile: ProofInfoLe
  (ExGen := list_to_set
              (evar_fresh_seq
                 (free_evars ψ ∪ free_evars p
                  ∪ free_evars q ∪ {[E]})
                 (maximal_exists_depth_to 0 E ψ)),
   SVSubst := list_to_set
                (svar_fresh_seq
                   (free_svars ψ ∪ free_svars p
                    ∪ free_svars q)
                   (maximal_mu_depth_to 0 E ψ)),
   KT := mu_in_evar_path E ψ 0) gpi
Hiff: Γ ⊢i p <---> q using gpi
H: well_formed (p <---> q)
H0: well_formed p
H1: well_formed q
∀ X : svar,
  X
  ∈ svar_fresh_seq
      (free_svars ψ ∪ free_svars p ∪ free_svars q)
      (maximal_mu_depth_to 0 E ψ)
  → X
    ∈ list_to_set
        (svar_fresh_seq
           (free_svars ψ ∪ free_svars p ∪ free_svars q)
           (maximal_mu_depth_to 0 E ψ))
Σ: Signature
Γ: Theory
p, q: Pattern
E: evar
ψ: Pattern
gpi: ProofInfo
wfp: well_formed p = true
wfq: well_formed q = true
wfC: PC_wf {| pcEvar := E; pcPattern := ψ |}
pile: ProofInfoLe
  (ExGen := list_to_set
              (evar_fresh_seq
                 (free_evars ψ ∪ free_evars p
                  ∪ free_evars q ∪ {[E]})
                 (maximal_exists_depth_to 0 E ψ)),
   SVSubst := list_to_set
                (svar_fresh_seq
                   (free_svars ψ ∪ free_svars p
                    ∪ free_svars q)
                   (maximal_mu_depth_to 0 E ψ)),
   KT := mu_in_evar_path E ψ 0) gpi
Hiff: Γ ⊢i p <---> q using gpi
H: well_formed (p <---> q)
H0: well_formed p
H1: well_formed q
ProofInfoLe
  (ExGen := list_to_set
              (evar_fresh_seq
                 (free_evars ψ ∪ free_evars p
                  ∪ free_evars q ∪ {[E]})
                 (maximal_exists_depth_to 0 E ψ)),
   SVSubst := list_to_set
                (svar_fresh_seq
                   (free_svars ψ ∪ free_svars p
                    ∪ free_svars q)
                   (maximal_mu_depth_to 0 E ψ)),
   KT := mu_in_evar_path E ψ 0) gpi
    {
Σ: Signature
Γ: Theory
p, q: Pattern
E: evar
ψ: Pattern
gpi: ProofInfo
wfp: well_formed p = true
wfq: well_formed q = true
wfC: PC_wf {| pcEvar := E; pcPattern := ψ |}
pile: ProofInfoLe
  (ExGen := list_to_set
              (evar_fresh_seq
                 (free_evars ψ ∪ free_evars p
                  ∪ free_evars q ∪ {[E]})
                 (maximal_exists_depth_to 0 E ψ)),
   SVSubst := list_to_set
                (svar_fresh_seq
                   (free_svars ψ ∪ free_svars p
                    ∪ free_svars q)
                   (maximal_mu_depth_to 0 E ψ)),
   KT := mu_in_evar_path E ψ 0) gpi
Hiff: Γ ⊢i p <---> q using gpi
H: well_formed (p <---> q)
H0: well_formed p
H1: well_formed q
∀ X : svar,
  X
  ∈ svar_fresh_seq
      (free_svars ψ ∪ free_svars p ∪ free_svars q)
      (maximal_mu_depth_to 0 E ψ)
  → X
    ∈ list_to_set
        (svar_fresh_seq
           (free_svars ψ ∪ free_svars p ∪ free_svars q)
           (maximal_mu_depth_to 0 E ψ)) intros.
Σ: Signature
Γ: Theory
p, q: Pattern
E: evar
ψ: Pattern
gpi: ProofInfo
wfp: well_formed p = true
wfq: well_formed q = true
wfC: PC_wf {| pcEvar := E; pcPattern := ψ |}
pile: ProofInfoLe
  (ExGen := list_to_set
              (evar_fresh_seq
                 (free_evars ψ ∪ free_evars p
                  ∪ free_evars q ∪ {[E]})
                 (maximal_exists_depth_to 0 E ψ)),
   SVSubst := list_to_set
                (svar_fresh_seq
                   (free_svars ψ ∪ free_svars p
                    ∪ free_svars q)
                   (maximal_mu_depth_to 0 E ψ)),
   KT := mu_in_evar_path E ψ 0) gpi
Hiff: Γ ⊢i p <---> q using gpi
H: well_formed (p <---> q)
H0: well_formed p
H1: well_formed q
X: svar
H2: X
∈ svar_fresh_seq
    (free_svars ψ ∪ free_svars p ∪ free_svars q)
    (maximal_mu_depth_to 0 E ψ)
X
∈ list_to_set
    (svar_fresh_seq
       (free_svars ψ ∪ free_svars p ∪ free_svars q)
       (maximal_mu_depth_to 0 E ψ)) set_solver. }
Σ: Signature
Γ: Theory
p, q: Pattern
E: evar
ψ: Pattern
gpi: ProofInfo
wfp: well_formed p = true
wfq: well_formed q = true
wfC: PC_wf {| pcEvar := E; pcPattern := ψ |}
pile: ProofInfoLe
  (ExGen := list_to_set
              (evar_fresh_seq
                 (free_evars ψ ∪ free_evars p
                  ∪ free_evars q ∪ {[E]})
                 (maximal_exists_depth_to 0 E ψ)),
   SVSubst := list_to_set
                (svar_fresh_seq
                   (free_svars ψ ∪ free_svars p
                    ∪ free_svars q)
                   (maximal_mu_depth_to 0 E ψ)),
   KT := mu_in_evar_path E ψ 0) gpi
Hiff: Γ ⊢i p <---> q using gpi
H: well_formed (p <---> q)
H0: well_formed p
H1: well_formed q
ProofInfoLe
  (ExGen := list_to_set
              (evar_fresh_seq
                 (free_evars ψ ∪ free_evars p
                  ∪ free_evars q ∪ {[E]})
                 (maximal_exists_depth_to 0 E ψ)),
   SVSubst := list_to_set
                (svar_fresh_seq
                   (free_svars ψ ∪ free_svars p
                    ∪ free_svars q)
                   (maximal_mu_depth_to 0 E ψ)),
   KT := mu_in_evar_path E ψ 0) gpi
    {
Σ: Signature
Γ: Theory
p, q: Pattern
E: evar
ψ: Pattern
gpi: ProofInfo
wfp: well_formed p = true
wfq: well_formed q = true
wfC: PC_wf {| pcEvar := E; pcPattern := ψ |}
pile: ProofInfoLe
  (ExGen := list_to_set
              (evar_fresh_seq
                 (free_evars ψ ∪ free_evars p
                  ∪ free_evars q ∪ {[E]})
                 (maximal_exists_depth_to 0 E ψ)),
   SVSubst := list_to_set
                (svar_fresh_seq
                   (free_svars ψ ∪ free_svars p
                    ∪ free_svars q)
                   (maximal_mu_depth_to 0 E ψ)),
   KT := mu_in_evar_path E ψ 0) gpi
Hiff: Γ ⊢i p <---> q using gpi
H: well_formed (p <---> q)
H0: well_formed p
H1: well_formed q
ProofInfoLe
  (ExGen := list_to_set
              (evar_fresh_seq
                 (free_evars ψ ∪ free_evars p
                  ∪ free_evars q ∪ {[E]})
                 (maximal_exists_depth_to 0 E ψ)),
   SVSubst := list_to_set
                (svar_fresh_seq
                   (free_svars ψ ∪ free_svars p
                    ∪ free_svars q)
                   (maximal_mu_depth_to 0 E ψ)),
   KT := mu_in_evar_path E ψ 0) gpi try_solve_pile. }
  Defined.

End FOL_helpers.

Lemma collapse_free_evar_subst {Σ : Signature} φ ψ x y:
  y ∉ free_evars φ ->
  φ^[[evar: x ↦ patt_free_evar y]]^[[evar: y ↦ ψ]] =
  φ^[[evar: x ↦ ψ]].
Σ: Signature
φ, ψ: Pattern
x, y: evar
y ∉ free_evars φ
→ φ^[[evar:x↦patt_free_evar y]]^[[evar:y↦ψ]] =
  φ^[[evar:x↦ψ]]
Proof.
Σ: Signature
φ, ψ: Pattern
x, y: evar
y ∉ free_evars φ
→ φ^[[evar:x↦patt_free_evar y]]^[[evar:y↦ψ]] =
  φ^[[evar:x↦ψ]]
  induction φ; simpl; auto; intro Hin.
Σ: Signature
x0: evar
ψ: Pattern
x, y: evar
Hin: y ∉ {[x0]}
(if decide (x = x0)
 then patt_free_evar y
 else patt_free_evar x0)^[[evar:y↦ψ]] =
(if decide (x = x0) then ψ else patt_free_evar x0)
Σ: Signature
φ1, φ2, ψ: Pattern
x, y: evar
IHφ1: y ∉ free_evars φ1
→ φ1^[[evar:x↦patt_free_evar y]]^[[evar:y↦ψ]] =
  φ1^[[evar:x↦ψ]]
IHφ2: y ∉ free_evars φ2
→ φ2^[[evar:x↦patt_free_evar y]]^[[evar:y↦ψ]] =
  φ2^[[evar:x↦ψ]]
Hin: y ∉ free_evars φ1 ∪ free_evars φ2
φ1^[[evar:x↦patt_free_evar y]]^[[evar:y↦ψ]] $
φ2^[[evar:x↦patt_free_evar y]]^[[evar:y↦ψ]] =
φ1^[[evar:x↦ψ]] $ φ2^[[evar:x↦ψ]]
Σ: Signature
φ1, φ2, ψ: Pattern
x, y: evar
IHφ1: y ∉ free_evars φ1
→ φ1^[[evar:x↦patt_free_evar y]]^[[evar:y↦ψ]] =
  φ1^[[evar:x↦ψ]]
IHφ2: y ∉ free_evars φ2
→ φ2^[[evar:x↦patt_free_evar y]]^[[evar:y↦ψ]] =
  φ2^[[evar:x↦ψ]]
Hin: y ∉ free_evars φ1 ∪ free_evars φ2
(φ1^[[evar:x↦patt_free_evar y]]^[[evar:y↦ψ]] --->
 φ2^[[evar:x↦patt_free_evar y]]^[[evar:y↦ψ]]) =
(φ1^[[evar:x↦ψ]] ---> φ2^[[evar:x↦ψ]])
Σ: Signature
φ, ψ: Pattern
x, y: evar
IHφ: y ∉ free_evars φ
→ φ^[[evar:x↦patt_free_evar y]]^[[evar:y↦ψ]] =
  φ^[[evar:x↦ψ]]
Hin: y ∉ free_evars φ
(ex , φ^[[evar:x↦patt_free_evar y]]^[[evar:y↦ψ]]) =
(ex , φ^[[evar:x↦ψ]])
Σ: Signature
φ, ψ: Pattern
x, y: evar
IHφ: y ∉ free_evars φ
→ φ^[[evar:x↦patt_free_evar y]]^[[evar:y↦ψ]] =
  φ^[[evar:x↦ψ]]
Hin: y ∉ free_evars φ
(mu , φ^[[evar:x↦patt_free_evar y]]^[[evar:y↦ψ]]) =
(mu , φ^[[evar:x↦ψ]])
  *
Σ: Signature
x0: evar
ψ: Pattern
x, y: evar
Hin: y ∉ {[x0]}
(if decide (x = x0)
 then patt_free_evar y
 else patt_free_evar x0)^[[evar:y↦ψ]] =
(if decide (x = x0) then ψ else patt_free_evar x0) repeat (case_match; simpl); auto.
Σ: Signature
x0: evar
ψ: Pattern
x, y: evar
Hin: y ∉ {[x0]}
e: x = x0
H: decide (x = x0) = left e
n: y ≠ y
H0: decide (y = y) = right n
patt_free_evar y = ψ
Σ: Signature
x0: evar
ψ: Pattern
x, y: evar
Hin: y ∉ {[x0]}
n: x ≠ x0
H: decide (x = x0) = right n
e: y = x0
H0: decide (y = x0) = left e
ψ = patt_free_evar x0 congruence.
Σ: Signature
x0: evar
ψ: Pattern
x, y: evar
Hin: y ∉ {[x0]}
n: x ≠ x0
H: decide (x = x0) = right n
e: y = x0
H0: decide (y = x0) = left e
ψ = patt_free_evar x0 set_solver.
  *
Σ: Signature
φ1, φ2, ψ: Pattern
x, y: evar
IHφ1: y ∉ free_evars φ1
→ φ1^[[evar:x↦patt_free_evar y]]^[[evar:y↦ψ]] =
  φ1^[[evar:x↦ψ]]
IHφ2: y ∉ free_evars φ2
→ φ2^[[evar:x↦patt_free_evar y]]^[[evar:y↦ψ]] =
  φ2^[[evar:x↦ψ]]
Hin: y ∉ free_evars φ1 ∪ free_evars φ2
φ1^[[evar:x↦patt_free_evar y]]^[[evar:y↦ψ]] $
φ2^[[evar:x↦patt_free_evar y]]^[[evar:y↦ψ]] =
φ1^[[evar:x↦ψ]] $ φ2^[[evar:x↦ψ]] rewrite IHφ1.
Σ: Signature
φ1, φ2, ψ: Pattern
x, y: evar
IHφ1: y ∉ free_evars φ1
→ φ1^[[evar:x↦patt_free_evar y]]^[[evar:y↦ψ]] =
  φ1^[[evar:x↦ψ]]
IHφ2: y ∉ free_evars φ2
→ φ2^[[evar:x↦patt_free_evar y]]^[[evar:y↦ψ]] =
  φ2^[[evar:x↦ψ]]
Hin: y ∉ free_evars φ1 ∪ free_evars φ2
y ∉ free_evars φ1
Σ: Signature
φ1, φ2, ψ: Pattern
x, y: evar
IHφ1: y ∉ free_evars φ1
→ φ1^[[evar:x↦patt_free_evar y]]^[[evar:y↦ψ]] =
  φ1^[[evar:x↦ψ]]
IHφ2: y ∉ free_evars φ2
→ φ2^[[evar:x↦patt_free_evar y]]^[[evar:y↦ψ]] =
  φ2^[[evar:x↦ψ]]
Hin: y ∉ free_evars φ1 ∪ free_evars φ2
φ1^[[evar:x↦ψ]] $
φ2^[[evar:x↦patt_free_evar y]]^[[evar:y↦ψ]] =
φ1^[[evar:x↦ψ]] $ φ2^[[evar:x↦ψ]] set_solver.
Σ: Signature
φ1, φ2, ψ: Pattern
x, y: evar
IHφ1: y ∉ free_evars φ1
→ φ1^[[evar:x↦patt_free_evar y]]^[[evar:y↦ψ]] =
  φ1^[[evar:x↦ψ]]
IHφ2: y ∉ free_evars φ2
→ φ2^[[evar:x↦patt_free_evar y]]^[[evar:y↦ψ]] =
  φ2^[[evar:x↦ψ]]
Hin: y ∉ free_evars φ1 ∪ free_evars φ2
φ1^[[evar:x↦ψ]] $
φ2^[[evar:x↦patt_free_evar y]]^[[evar:y↦ψ]] =
φ1^[[evar:x↦ψ]] $ φ2^[[evar:x↦ψ]] rewrite IHφ2.
Σ: Signature
φ1, φ2, ψ: Pattern
x, y: evar
IHφ1: y ∉ free_evars φ1
→ φ1^[[evar:x↦patt_free_evar y]]^[[evar:y↦ψ]] =
  φ1^[[evar:x↦ψ]]
IHφ2: y ∉ free_evars φ2
→ φ2^[[evar:x↦patt_free_evar y]]^[[evar:y↦ψ]] =
  φ2^[[evar:x↦ψ]]
Hin: y ∉ free_evars φ1 ∪ free_evars φ2
y ∉ free_evars φ2
Σ: Signature
φ1, φ2, ψ: Pattern
x, y: evar
IHφ1: y ∉ free_evars φ1
→ φ1^[[evar:x↦patt_free_evar y]]^[[evar:y↦ψ]] =
  φ1^[[evar:x↦ψ]]
IHφ2: y ∉ free_evars φ2
→ φ2^[[evar:x↦patt_free_evar y]]^[[evar:y↦ψ]] =
  φ2^[[evar:x↦ψ]]
Hin: y ∉ free_evars φ1 ∪ free_evars φ2
φ1^[[evar:x↦ψ]] $ φ2^[[evar:x↦ψ]] =
φ1^[[evar:x↦ψ]] $ φ2^[[evar:x↦ψ]] set_solver.
Σ: Signature
φ1, φ2, ψ: Pattern
x, y: evar
IHφ1: y ∉ free_evars φ1
→ φ1^[[evar:x↦patt_free_evar y]]^[[evar:y↦ψ]] =
  φ1^[[evar:x↦ψ]]
IHφ2: y ∉ free_evars φ2
→ φ2^[[evar:x↦patt_free_evar y]]^[[evar:y↦ψ]] =
  φ2^[[evar:x↦ψ]]
Hin: y ∉ free_evars φ1 ∪ free_evars φ2
φ1^[[evar:x↦ψ]] $ φ2^[[evar:x↦ψ]] =
φ1^[[evar:x↦ψ]] $ φ2^[[evar:x↦ψ]] reflexivity.
  *
Σ: Signature
φ1, φ2, ψ: Pattern
x, y: evar
IHφ1: y ∉ free_evars φ1
→ φ1^[[evar:x↦patt_free_evar y]]^[[evar:y↦ψ]] =
  φ1^[[evar:x↦ψ]]
IHφ2: y ∉ free_evars φ2
→ φ2^[[evar:x↦patt_free_evar y]]^[[evar:y↦ψ]] =
  φ2^[[evar:x↦ψ]]
Hin: y ∉ free_evars φ1 ∪ free_evars φ2
(φ1^[[evar:x↦patt_free_evar y]]^[[evar:y↦ψ]] --->
 φ2^[[evar:x↦patt_free_evar y]]^[[evar:y↦ψ]]) =
(φ1^[[evar:x↦ψ]] ---> φ2^[[evar:x↦ψ]]) rewrite IHφ1.
Σ: Signature
φ1, φ2, ψ: Pattern
x, y: evar
IHφ1: y ∉ free_evars φ1
→ φ1^[[evar:x↦patt_free_evar y]]^[[evar:y↦ψ]] =
  φ1^[[evar:x↦ψ]]
IHφ2: y ∉ free_evars φ2
→ φ2^[[evar:x↦patt_free_evar y]]^[[evar:y↦ψ]] =
  φ2^[[evar:x↦ψ]]
Hin: y ∉ free_evars φ1 ∪ free_evars φ2
y ∉ free_evars φ1
Σ: Signature
φ1, φ2, ψ: Pattern
x, y: evar
IHφ1: y ∉ free_evars φ1
→ φ1^[[evar:x↦patt_free_evar y]]^[[evar:y↦ψ]] =
  φ1^[[evar:x↦ψ]]
IHφ2: y ∉ free_evars φ2
→ φ2^[[evar:x↦patt_free_evar y]]^[[evar:y↦ψ]] =
  φ2^[[evar:x↦ψ]]
Hin: y ∉ free_evars φ1 ∪ free_evars φ2
(φ1^[[evar:x↦ψ]] --->
 φ2^[[evar:x↦patt_free_evar y]]^[[evar:y↦ψ]]) =
(φ1^[[evar:x↦ψ]] ---> φ2^[[evar:x↦ψ]]) set_solver.
Σ: Signature
φ1, φ2, ψ: Pattern
x, y: evar
IHφ1: y ∉ free_evars φ1
→ φ1^[[evar:x↦patt_free_evar y]]^[[evar:y↦ψ]] =
  φ1^[[evar:x↦ψ]]
IHφ2: y ∉ free_evars φ2
→ φ2^[[evar:x↦patt_free_evar y]]^[[evar:y↦ψ]] =
  φ2^[[evar:x↦ψ]]
Hin: y ∉ free_evars φ1 ∪ free_evars φ2
(φ1^[[evar:x↦ψ]] --->
 φ2^[[evar:x↦patt_free_evar y]]^[[evar:y↦ψ]]) =
(φ1^[[evar:x↦ψ]] ---> φ2^[[evar:x↦ψ]]) rewrite IHφ2.
Σ: Signature
φ1, φ2, ψ: Pattern
x, y: evar
IHφ1: y ∉ free_evars φ1
→ φ1^[[evar:x↦patt_free_evar y]]^[[evar:y↦ψ]] =
  φ1^[[evar:x↦ψ]]
IHφ2: y ∉ free_evars φ2
→ φ2^[[evar:x↦patt_free_evar y]]^[[evar:y↦ψ]] =
  φ2^[[evar:x↦ψ]]
Hin: y ∉ free_evars φ1 ∪ free_evars φ2
y ∉ free_evars φ2
Σ: Signature
φ1, φ2, ψ: Pattern
x, y: evar
IHφ1: y ∉ free_evars φ1
→ φ1^[[evar:x↦patt_free_evar y]]^[[evar:y↦ψ]] =
  φ1^[[evar:x↦ψ]]
IHφ2: y ∉ free_evars φ2
→ φ2^[[evar:x↦patt_free_evar y]]^[[evar:y↦ψ]] =
  φ2^[[evar:x↦ψ]]
Hin: y ∉ free_evars φ1 ∪ free_evars φ2
(φ1^[[evar:x↦ψ]] ---> φ2^[[evar:x↦ψ]]) =
(φ1^[[evar:x↦ψ]] ---> φ2^[[evar:x↦ψ]]) set_solver.
Σ: Signature
φ1, φ2, ψ: Pattern
x, y: evar
IHφ1: y ∉ free_evars φ1
→ φ1^[[evar:x↦patt_free_evar y]]^[[evar:y↦ψ]] =
  φ1^[[evar:x↦ψ]]
IHφ2: y ∉ free_evars φ2
→ φ2^[[evar:x↦patt_free_evar y]]^[[evar:y↦ψ]] =
  φ2^[[evar:x↦ψ]]
Hin: y ∉ free_evars φ1 ∪ free_evars φ2
(φ1^[[evar:x↦ψ]] ---> φ2^[[evar:x↦ψ]]) =
(φ1^[[evar:x↦ψ]] ---> φ2^[[evar:x↦ψ]]) reflexivity.
  *
Σ: Signature
φ, ψ: Pattern
x, y: evar
IHφ: y ∉ free_evars φ
→ φ^[[evar:x↦patt_free_evar y]]^[[evar:y↦ψ]] = φ^[[evar:x↦ψ]]
Hin: y ∉ free_evars φ
(ex , φ^[[evar:x↦patt_free_evar y]]^[[evar:y↦ψ]]) =
(ex , φ^[[evar:x↦ψ]]) rewrite IHφ.
Σ: Signature
φ, ψ: Pattern
x, y: evar
IHφ: y ∉ free_evars φ
→ φ^[[evar:x↦patt_free_evar y]]^[[evar:y↦ψ]] = φ^[[evar:x↦ψ]]
Hin: y ∉ free_evars φ
y ∉ free_evars φ
Σ: Signature
φ, ψ: Pattern
x, y: evar
IHφ: y ∉ free_evars φ
→ φ^[[evar:x↦patt_free_evar y]]^[[evar:y↦ψ]] = φ^[[evar:x↦ψ]]
Hin: y ∉ free_evars φ
(ex , φ^[[evar:x↦ψ]]) = (ex , φ^[[evar:x↦ψ]]) set_solver.
Σ: Signature
φ, ψ: Pattern
x, y: evar
IHφ: y ∉ free_evars φ
→ φ^[[evar:x↦patt_free_evar y]]^[[evar:y↦ψ]] = φ^[[evar:x↦ψ]]
Hin: y ∉ free_evars φ
(ex , φ^[[evar:x↦ψ]]) = (ex , φ^[[evar:x↦ψ]]) reflexivity.
  *
Σ: Signature
φ, ψ: Pattern
x, y: evar
IHφ: y ∉ free_evars φ
→ φ^[[evar:x↦patt_free_evar y]]^[[evar:y↦ψ]] = φ^[[evar:x↦ψ]]
Hin: y ∉ free_evars φ
(mu , φ^[[evar:x↦patt_free_evar y]]^[[evar:y↦ψ]]) =
(mu , φ^[[evar:x↦ψ]]) rewrite IHφ.
Σ: Signature
φ, ψ: Pattern
x, y: evar
IHφ: y ∉ free_evars φ
→ φ^[[evar:x↦patt_free_evar y]]^[[evar:y↦ψ]] = φ^[[evar:x↦ψ]]
Hin: y ∉ free_evars φ
y ∉ free_evars φ
Σ: Signature
φ, ψ: Pattern
x, y: evar
IHφ: y ∉ free_evars φ
→ φ^[[evar:x↦patt_free_evar y]]^[[evar:y↦ψ]] = φ^[[evar:x↦ψ]]
Hin: y ∉ free_evars φ
(mu , φ^[[evar:x↦ψ]]) = (mu , φ^[[evar:x↦ψ]]) set_solver.
Σ: Signature
φ, ψ: Pattern
x, y: evar
IHφ: y ∉ free_evars φ
→ φ^[[evar:x↦patt_free_evar y]]^[[evar:y↦ψ]] = φ^[[evar:x↦ψ]]
Hin: y ∉ free_evars φ
(mu , φ^[[evar:x↦ψ]]) = (mu , φ^[[evar:x↦ψ]]) reflexivity.
Qed.

Lemma fresh_foldr_is_context {Σ : Signature} l C p:
  pcEvar C ∉ free_evars_of_list l ->
  foldr patt_imp (emplace C p) l =
  emplace
    {|pcEvar := pcEvar C;
      pcPattern := foldr patt_imp (pcPattern C) l |} p.
Σ: Signature
l: list Pattern
C: PatternCtx
p: Pattern
pcEvar C ∉ free_evars_of_list l
→ foldr patt_imp (C [p]) l =
  ({|
     pcEvar := pcEvar C;
     pcPattern := foldr patt_imp (pcPattern C) l
   |} [p])
Proof.
Σ: Signature
l: list Pattern
C: PatternCtx
p: Pattern
pcEvar C ∉ free_evars_of_list l
→ foldr patt_imp (C [p]) l =
  ({|
     pcEvar := pcEvar C;
     pcPattern := foldr patt_imp (pcPattern C) l
   |} [p])
  revert C p.
Σ: Signature
l: list Pattern
∀ (C : PatternCtx) (p : Pattern),
  pcEvar C ∉ free_evars_of_list l
  → foldr patt_imp (C [p]) l =
    ({|
       pcEvar := pcEvar C;
       pcPattern := foldr patt_imp (pcPattern C) l
     |} [p]) induction l; intros C p Hin; cbn.
Σ: Signature
C: PatternCtx
p: Pattern
Hin: pcEvar C ∉ free_evars_of_list []
(C [p]) = (pcPattern C)^[[evar:pcEvar C↦p]]
Σ: Signature
a: Pattern
l: list Pattern
IHl: ∀ (C : PatternCtx) (p : Pattern),
pcEvar C ∉ free_evars_of_list l
→ foldr patt_imp (C [p]) l =
({| pcEvar := pcEvar C; pcPattern := foldr patt_imp (pcPattern C) l |}
[p])
C: PatternCtx
p: Pattern
Hin: pcEvar C ∉ free_evars_of_list (a :: l)
(a ---> foldr patt_imp (C [p]) l) =
(a^[[evar:pcEvar C↦p]] --->
 (foldr patt_imp (pcPattern C) l)^[[evar:pcEvar C↦p]])
  {
Σ: Signature
C: PatternCtx
p: Pattern
Hin: pcEvar C ∉ free_evars_of_list []
(C [p]) = (pcPattern C)^[[evar:pcEvar C↦p]]
    auto.
  }
Σ: Signature
a: Pattern
l: list Pattern
IHl: ∀ (C : PatternCtx) (p : Pattern),
pcEvar C ∉ free_evars_of_list l
→ foldr patt_imp (C [p]) l =
({| pcEvar := pcEvar C; pcPattern := foldr patt_imp (pcPattern C) l |}
[p])
C: PatternCtx
p: Pattern
Hin: pcEvar C ∉ free_evars_of_list (a :: l)
(a ---> foldr patt_imp (C [p]) l) =
(a^[[evar:pcEvar C↦p]] --->
 (foldr patt_imp (pcPattern C) l)^[[evar:pcEvar C↦p]])
  {
Σ: Signature
a: Pattern
l: list Pattern
IHl: ∀ (C : PatternCtx) (p : Pattern),
pcEvar C ∉ free_evars_of_list l
→ foldr patt_imp (C [p]) l =
({| pcEvar := pcEvar C; pcPattern := foldr patt_imp (pcPattern C) l |}
[p])
C: PatternCtx
p: Pattern
Hin: pcEvar C ∉ free_evars_of_list (a :: l)
(a ---> foldr patt_imp (C [p]) l) =
(a^[[evar:pcEvar C↦p]] --->
 (foldr patt_imp (pcPattern C) l)^[[evar:pcEvar C↦p]])
    simpl in Hin.
Σ: Signature
a: Pattern
l: list Pattern
IHl: ∀ (C : PatternCtx) (p : Pattern),
pcEvar C ∉ free_evars_of_list l
→ foldr patt_imp (C [p]) l =
({| pcEvar := pcEvar C; pcPattern := foldr patt_imp (pcPattern C) l |}
[p])
C: PatternCtx
p: Pattern
Hin: pcEvar C ∉ free_evars_of_list (a :: l)
(a ---> foldr patt_imp (C [p]) l) =
(a^[[evar:pcEvar C↦p]] --->
 (foldr patt_imp (pcPattern C) l)^[[evar:pcEvar C↦p]])
    rewrite free_evar_subst_no_occurrence.
Σ: Signature
a: Pattern
l: list Pattern
IHl: ∀ (C : PatternCtx) (p : Pattern),
pcEvar C ∉ free_evars_of_list l
→ foldr patt_imp (C [p]) l =
({| pcEvar := pcEvar C; pcPattern := foldr patt_imp (pcPattern C) l |}
[p])
C: PatternCtx
p: Pattern
Hin: pcEvar C ∉ free_evars_of_list (a :: l)
pcEvar C ∉ free_evars a
Σ: Signature
a: Pattern
l: list Pattern
IHl: ∀ (C : PatternCtx) (p : Pattern),
pcEvar C ∉ free_evars_of_list l
→ foldr patt_imp (C [p]) l =
({| pcEvar := pcEvar C; pcPattern := foldr patt_imp (pcPattern C) l |}
[p])
C: PatternCtx
p: Pattern
Hin: pcEvar C ∉ free_evars_of_list (a :: l)
(a ---> foldr patt_imp (C [p]) l) =
(a --->
 (foldr patt_imp (pcPattern C) l)^[[evar:pcEvar C↦p]])
    *
Σ: Signature
a: Pattern
l: list Pattern
IHl: ∀ (C : PatternCtx) (p : Pattern),
pcEvar C ∉ free_evars_of_list l
→ foldr patt_imp (C [p]) l =
({| pcEvar := pcEvar C; pcPattern := foldr patt_imp (pcPattern C) l |}
[p])
C: PatternCtx
p: Pattern
Hin: pcEvar C ∉ free_evars_of_list (a :: l)
pcEvar C ∉ free_evars a simpl in Hin.
Σ: Signature
a: Pattern
l: list Pattern
IHl: ∀ (C : PatternCtx) (p : Pattern),
pcEvar C ∉ free_evars_of_list l
→ foldr patt_imp (C [p]) l =
({| pcEvar := pcEvar C; pcPattern := foldr patt_imp (pcPattern C) l |}
[p])
C: PatternCtx
p: Pattern
Hin: pcEvar C ∉ free_evars_of_list (a :: l)
pcEvar C ∉ free_evars a solve_free_evars 5.
    *
Σ: Signature
a: Pattern
l: list Pattern
IHl: ∀ (C : PatternCtx) (p : Pattern),
pcEvar C ∉ free_evars_of_list l
→ foldr patt_imp (C [p]) l =
({| pcEvar := pcEvar C; pcPattern := foldr patt_imp (pcPattern C) l |}
[p])
C: PatternCtx
p: Pattern
Hin: pcEvar C ∉ free_evars_of_list (a :: l)
(a ---> foldr patt_imp (C [p]) l) =
(a --->
 (foldr patt_imp (pcPattern C) l)^[[evar:pcEvar C↦p]]) f_equal.
Σ: Signature
a: Pattern
l: list Pattern
IHl: ∀ (C : PatternCtx) (p : Pattern),
pcEvar C ∉ free_evars_of_list l
→ foldr patt_imp (C [p]) l =
({| pcEvar := pcEvar C; pcPattern := foldr patt_imp (pcPattern C) l |}
[p])
C: PatternCtx
p: Pattern
Hin: pcEvar C ∉ free_evars_of_list (a :: l)
foldr patt_imp (C [p]) l =
(foldr patt_imp (pcPattern C) l)^[[evar:pcEvar C↦p]] apply IHl.
Σ: Signature
a: Pattern
l: list Pattern
IHl: ∀ (C : PatternCtx) (p : Pattern),
pcEvar C ∉ free_evars_of_list l
→ foldr patt_imp (C [p]) l =
({| pcEvar := pcEvar C; pcPattern := foldr patt_imp (pcPattern C) l |}
[p])
C: PatternCtx
p: Pattern
Hin: pcEvar C ∉ free_evars_of_list (a :: l)
pcEvar C ∉ free_evars_of_list l solve_free_evars 5.
  }
Qed.

(** NOTE: the following lemmas are very specific for prf_equiv_congruence_iter  *)

Lemma maximal_exists_depth_foldr_notin {Σ : Signature} l ψ x edepth:
  x ∉ free_evars_of_list l ->
  maximal_exists_depth_to edepth x (foldr patt_imp ψ l) =
  maximal_exists_depth_to edepth x ψ.
Σ: Signature
l: list Pattern
ψ: Pattern
x: evar
edepth: nat
x ∉ free_evars_of_list l
→ maximal_exists_depth_to edepth x
    (foldr patt_imp ψ l) =
  maximal_exists_depth_to edepth x ψ
Proof.
Σ: Signature
l: list Pattern
ψ: Pattern
x: evar
edepth: nat
x ∉ free_evars_of_list l
→ maximal_exists_depth_to edepth x
    (foldr patt_imp ψ l) =
  maximal_exists_depth_to edepth x ψ
  induction l; simpl; intros Hin.
Σ: Signature
ψ: Pattern
x: evar
edepth: nat
Hin: x ∉ free_evars_of_list []
maximal_exists_depth_to edepth x ψ =
maximal_exists_depth_to edepth x ψ
Σ: Signature
a: Pattern
l: list Pattern
ψ: Pattern
x: evar
edepth: nat
IHl: x ∉ free_evars_of_list l
→ maximal_exists_depth_to edepth x
    (foldr patt_imp ψ l) =
  maximal_exists_depth_to edepth x ψ
Hin: x ∉ free_evars_of_list (a :: l)
maximal_exists_depth_to edepth x a
`max` maximal_exists_depth_to edepth x
        (foldr patt_imp ψ l) =
maximal_exists_depth_to edepth x ψ
  *
Σ: Signature
ψ: Pattern
x: evar
edepth: nat
Hin: x ∉ free_evars_of_list []
maximal_exists_depth_to edepth x ψ =
maximal_exists_depth_to edepth x ψ reflexivity.
  *
Σ: Signature
a: Pattern
l: list Pattern
ψ: Pattern
x: evar
edepth: nat
IHl: x ∉ free_evars_of_list l
→ maximal_exists_depth_to edepth x
    (foldr patt_imp ψ l) =
  maximal_exists_depth_to edepth x ψ
Hin: x ∉ free_evars_of_list (a :: l)
maximal_exists_depth_to edepth x a
`max` maximal_exists_depth_to edepth x
        (foldr patt_imp ψ l) =
maximal_exists_depth_to edepth x ψ assert (x ∉ free_evars a) as Ha by solve_free_evars 1.
Σ: Signature
a: Pattern
l: list Pattern
ψ: Pattern
x: evar
edepth: nat
IHl: x ∉ free_evars_of_list l
→ maximal_exists_depth_to edepth x
    (foldr patt_imp ψ l) =
  maximal_exists_depth_to edepth x ψ
Hin: x ∉ free_evars_of_list (a :: l)
Ha: x ∉ free_evars a
maximal_exists_depth_to edepth x a
`max` maximal_exists_depth_to edepth x
        (foldr patt_imp ψ l) =
maximal_exists_depth_to edepth x ψ
    assert (x ∉ free_evars_of_list l) as HIND by solve_free_evars 1.
Σ: Signature
a: Pattern
l: list Pattern
ψ: Pattern
x: evar
edepth: nat
IHl: x ∉ free_evars_of_list l
→ maximal_exists_depth_to edepth x
    (foldr patt_imp ψ l) =
  maximal_exists_depth_to edepth x ψ
Hin: x ∉ free_evars_of_list (a :: l)
Ha: x ∉ free_evars a
HIND: x ∉ free_evars_of_list l
maximal_exists_depth_to edepth x a
`max` maximal_exists_depth_to edepth x
        (foldr patt_imp ψ l) =
maximal_exists_depth_to edepth x ψ
    apply IHl in HIND.
Σ: Signature
a: Pattern
l: list Pattern
ψ: Pattern
x: evar
edepth: nat
IHl: x ∉ free_evars_of_list l
→ maximal_exists_depth_to edepth x
    (foldr patt_imp ψ l) =
  maximal_exists_depth_to edepth x ψ
Hin: x ∉ free_evars_of_list (a :: l)
Ha: x ∉ free_evars a
HIND: maximal_exists_depth_to edepth x
  (foldr patt_imp ψ l) =
maximal_exists_depth_to edepth x ψ
maximal_exists_depth_to edepth x a
`max` maximal_exists_depth_to edepth x
        (foldr patt_imp ψ l) =
maximal_exists_depth_to edepth x ψ rewrite HIND.
Σ: Signature
a: Pattern
l: list Pattern
ψ: Pattern
x: evar
edepth: nat
IHl: x ∉ free_evars_of_list l
→ maximal_exists_depth_to edepth x
    (foldr patt_imp ψ l) =
  maximal_exists_depth_to edepth x ψ
Hin: x ∉ free_evars_of_list (a :: l)
Ha: x ∉ free_evars a
HIND: maximal_exists_depth_to edepth x
  (foldr patt_imp ψ l) =
maximal_exists_depth_to edepth x ψ
maximal_exists_depth_to edepth x a
`max` maximal_exists_depth_to edepth x ψ =
maximal_exists_depth_to edepth x ψ
    rewrite maximal_exists_depth_to_0; auto.
Qed.

Lemma maximal_mu_depth_foldr_notin {Σ : Signature} l ψ x edepth:
  x ∉ free_evars_of_list l ->
  maximal_mu_depth_to edepth x (foldr patt_imp ψ l) =
  maximal_mu_depth_to edepth x ψ.
Σ: Signature
l: list Pattern
ψ: Pattern
x: evar
edepth: nat
x ∉ free_evars_of_list l
→ maximal_mu_depth_to edepth x (foldr patt_imp ψ l) =
  maximal_mu_depth_to edepth x ψ
Proof.
Σ: Signature
l: list Pattern
ψ: Pattern
x: evar
edepth: nat
x ∉ free_evars_of_list l
→ maximal_mu_depth_to edepth x (foldr patt_imp ψ l) =
  maximal_mu_depth_to edepth x ψ
  induction l; simpl; intros Hin.
Σ: Signature
ψ: Pattern
x: evar
edepth: nat
Hin: x ∉ free_evars_of_list []
maximal_mu_depth_to edepth x ψ =
maximal_mu_depth_to edepth x ψ
Σ: Signature
a: Pattern
l: list Pattern
ψ: Pattern
x: evar
edepth: nat
IHl: x ∉ free_evars_of_list l
→ maximal_mu_depth_to edepth x
    (foldr patt_imp ψ l) =
  maximal_mu_depth_to edepth x ψ
Hin: x ∉ free_evars_of_list (a :: l)
maximal_mu_depth_to edepth x a
`max` maximal_mu_depth_to edepth x
        (foldr patt_imp ψ l) =
maximal_mu_depth_to edepth x ψ
  *
Σ: Signature
ψ: Pattern
x: evar
edepth: nat
Hin: x ∉ free_evars_of_list []
maximal_mu_depth_to edepth x ψ =
maximal_mu_depth_to edepth x ψ reflexivity.
  *
Σ: Signature
a: Pattern
l: list Pattern
ψ: Pattern
x: evar
edepth: nat
IHl: x ∉ free_evars_of_list l
→ maximal_mu_depth_to edepth x
    (foldr patt_imp ψ l) =
  maximal_mu_depth_to edepth x ψ
Hin: x ∉ free_evars_of_list (a :: l)
maximal_mu_depth_to edepth x a
`max` maximal_mu_depth_to edepth x
        (foldr patt_imp ψ l) =
maximal_mu_depth_to edepth x ψ assert (x ∉ free_evars a) as Ha by solve_free_evars 1.
Σ: Signature
a: Pattern
l: list Pattern
ψ: Pattern
x: evar
edepth: nat
IHl: x ∉ free_evars_of_list l
→ maximal_mu_depth_to edepth x
    (foldr patt_imp ψ l) =
  maximal_mu_depth_to edepth x ψ
Hin: x ∉ free_evars_of_list (a :: l)
Ha: x ∉ free_evars a
maximal_mu_depth_to edepth x a
`max` maximal_mu_depth_to edepth x
        (foldr patt_imp ψ l) =
maximal_mu_depth_to edepth x ψ
    assert (x ∉ free_evars_of_list l) as HIND by solve_free_evars 1.
Σ: Signature
a: Pattern
l: list Pattern
ψ: Pattern
x: evar
edepth: nat
IHl: x ∉ free_evars_of_list l
→ maximal_mu_depth_to edepth x
    (foldr patt_imp ψ l) =
  maximal_mu_depth_to edepth x ψ
Hin: x ∉ free_evars_of_list (a :: l)
Ha: x ∉ free_evars a
HIND: x ∉ free_evars_of_list l
maximal_mu_depth_to edepth x a
`max` maximal_mu_depth_to edepth x
        (foldr patt_imp ψ l) =
maximal_mu_depth_to edepth x ψ
    apply IHl in HIND.
Σ: Signature
a: Pattern
l: list Pattern
ψ: Pattern
x: evar
edepth: nat
IHl: x ∉ free_evars_of_list l
→ maximal_mu_depth_to edepth x
    (foldr patt_imp ψ l) =
  maximal_mu_depth_to edepth x ψ
Hin: x ∉ free_evars_of_list (a :: l)
Ha: x ∉ free_evars a
HIND: maximal_mu_depth_to edepth x
  (foldr patt_imp ψ l) =
maximal_mu_depth_to edepth x ψ
maximal_mu_depth_to edepth x a
`max` maximal_mu_depth_to edepth x
        (foldr patt_imp ψ l) =
maximal_mu_depth_to edepth x ψ rewrite HIND.
Σ: Signature
a: Pattern
l: list Pattern
ψ: Pattern
x: evar
edepth: nat
IHl: x ∉ free_evars_of_list l
→ maximal_mu_depth_to edepth x
    (foldr patt_imp ψ l) =
  maximal_mu_depth_to edepth x ψ
Hin: x ∉ free_evars_of_list (a :: l)
Ha: x ∉ free_evars a
HIND: maximal_mu_depth_to edepth x
  (foldr patt_imp ψ l) =
maximal_mu_depth_to edepth x ψ
maximal_mu_depth_to edepth x a
`max` maximal_mu_depth_to edepth x ψ =
maximal_mu_depth_to edepth x ψ
    rewrite maximal_mu_depth_to_0; auto.
Qed.

(* NOTE: This version of the iterated congruence lemma is proved by induction.
         There is a way, to prove this lemma without induction (see
         `TEST_proofmode_proof_size.v`), but the generated proof term becomes
         much more larger (2-3 times larger than the induction-based).
         This is because the proof of the congruence lemma is more complex
         for bigger contexts. *)
Lemma prf_equiv_congruence_iter {Σ : Signature} (Γ : Theory) (p q : Pattern) (C : PatternCtx) l
  (wfp : well_formed p)
  (wfq : well_formed q)
  (wfC : PC_wf C)
  (gpi : ProofInfo)
  (pile : ProofInfoLe
    (ExGen := list_to_set (evar_fresh_seq (free_evars (pcPattern C) ∪ free_evars p ∪ free_evars q ∪ {[pcEvar C]}) (maximal_exists_depth_to 0 (pcEvar C) (pcPattern C))),
      SVSubst := list_to_set (svar_fresh_seq (free_svars (pcPattern C) ∪ free_svars p ∪ free_svars q) (maximal_mu_depth_to 0 (pcEvar C) (pcPattern C))),
      KT := mu_in_evar_path (pcEvar C) (pcPattern C) 0
    )
    ( gpi)
  ):
  Pattern.wf l ->
  Γ ⊢i p <---> q using ( gpi) ->
  Γ ⊢i (foldr patt_imp (emplace C p) l) <---> (foldr patt_imp (emplace C q) l) using ( gpi).
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
l: list Pattern
wfp: well_formed p
wfq: well_formed q
wfC: PC_wf C
gpi: ProofInfo
pile: ProofInfoLe
  (ExGen := list_to_set
              (evar_fresh_seq
                 (free_evars (pcPattern C)
                  ∪ free_evars p ∪ 
                  free_evars q ∪ {[
                  pcEvar C]})
                 (maximal_exists_depth_to 0
                    (pcEvar C) 
                    (pcPattern C))),
   SVSubst := list_to_set
                (svar_fresh_seq
                   (free_svars (pcPattern C)
                    ∪ free_svars p
                    ∪ free_svars q)
                   (maximal_mu_depth_to 0
                      (pcEvar C) 
                      (pcPattern C))),
   KT := mu_in_evar_path 
           (pcEvar C) (pcPattern C) 0) gpi
wf l
→ Γ ⊢i p <---> q using gpi
  → Γ
    ⊢i foldr patt_imp (C [p]) l <--->
       foldr patt_imp (C [q]) l using gpi
Proof.
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
l: list Pattern
wfp: well_formed p
wfq: well_formed q
wfC: PC_wf C
gpi: ProofInfo
pile: ProofInfoLe
  (ExGen := list_to_set
              (evar_fresh_seq
                 (free_evars (pcPattern C)
                  ∪ free_evars p ∪ 
                  free_evars q ∪ {[
                  pcEvar C]})
                 (maximal_exists_depth_to 0
                    (pcEvar C) 
                    (pcPattern C))),
   SVSubst := list_to_set
                (svar_fresh_seq
                   (free_svars (pcPattern C)
                    ∪ free_svars p
                    ∪ free_svars q)
                   (maximal_mu_depth_to 0
                      (pcEvar C) 
                      (pcPattern C))),
   KT := mu_in_evar_path 
           (pcEvar C) (pcPattern C) 0) gpi
wf l
→ Γ ⊢i p <---> q using gpi
  → Γ
    ⊢i foldr patt_imp (C [p]) l <--->
       foldr patt_imp (C [q]) l using gpi
  intros wfl Himp.
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
l: list Pattern
wfp: well_formed p
wfq: well_formed q
wfC: PC_wf C
gpi: ProofInfo
pile: ProofInfoLe
  (ExGen := list_to_set
              (evar_fresh_seq
                 (free_evars (pcPattern C)
                  ∪ free_evars p ∪ 
                  free_evars q ∪ {[
                  pcEvar C]})
                 (maximal_exists_depth_to 0
                    (pcEvar C) 
                    (pcPattern C))),
   SVSubst := list_to_set
                (svar_fresh_seq
                   (free_svars (pcPattern C)
                    ∪ free_svars p
                    ∪ free_svars q)
                   (maximal_mu_depth_to 0
                      (pcEvar C) 
                      (pcPattern C))),
   KT := mu_in_evar_path 
           (pcEvar C) (pcPattern C) 0) gpi
wfl: wf l
Himp: Γ ⊢i p <---> q using gpi
Γ
⊢i foldr patt_imp (C [p]) l <--->
   foldr patt_imp (C [q]) l using gpi
  induction l; simpl in *.
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
wfp: well_formed p
wfq: well_formed q
wfC: PC_wf C
gpi: ProofInfo
pile: ProofInfoLe
  (ExGen := list_to_set
              (evar_fresh_seq
                 (free_evars (pcPattern C)
                  ∪ free_evars p ∪ 
                  free_evars q ∪ {[
                  pcEvar C]})
                 (maximal_exists_depth_to 0
                    (pcEvar C) 
                    (pcPattern C))),
   SVSubst := list_to_set
                (svar_fresh_seq
                   (free_svars (pcPattern C)
                    ∪ free_svars p
                    ∪ free_svars q)
                   (maximal_mu_depth_to 0
                      (pcEvar C) 
                      (pcPattern C))),
   KT := mu_in_evar_path 
           (pcEvar C) (pcPattern C) 0) gpi
wfl: wf []
Himp: Γ ⊢i p <---> q using gpi
Γ ⊢i (C [p]) <---> (C [q]) using gpi
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
a: Pattern
l: list Pattern
wfp: well_formed p
wfq: well_formed q
wfC: PC_wf C
gpi: ProofInfo
pile: ProofInfoLe
  (ExGen := list_to_set
              (evar_fresh_seq
                 (free_evars (pcPattern C)
                  ∪ free_evars p ∪ 
                  free_evars q ∪ {[
                  pcEvar C]})
                 (maximal_exists_depth_to 0
                    (pcEvar C) 
                    (pcPattern C))),
   SVSubst := list_to_set
                (svar_fresh_seq
                   (free_svars (pcPattern C)
                    ∪ free_svars p
                    ∪ free_svars q)
                   (maximal_mu_depth_to 0
                      (pcEvar C) 
                      (pcPattern C))),
   KT := mu_in_evar_path 
           (pcEvar C) (pcPattern C) 0) gpi
wfl: wf (a :: l)
Himp: Γ ⊢i p <---> q using gpi
IHl: wf l
→ Γ
  ⊢i foldr patt_imp (C [p]) l <--->
     foldr patt_imp (C [q]) l using gpi
Γ
⊢i (a ---> foldr patt_imp (C [p]) l) <--->
   (a ---> foldr patt_imp (C [q]) l) using gpi
  -
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
wfp: well_formed p
wfq: well_formed q
wfC: PC_wf C
gpi: ProofInfo
pile: ProofInfoLe
  (ExGen := list_to_set
              (evar_fresh_seq
                 (free_evars (pcPattern C)
                  ∪ free_evars p ∪ 
                  free_evars q ∪ {[
                  pcEvar C]})
                 (maximal_exists_depth_to 0
                    (pcEvar C) 
                    (pcPattern C))),
   SVSubst := list_to_set
                (svar_fresh_seq
                   (free_svars (pcPattern C)
                    ∪ free_svars p
                    ∪ free_svars q)
                   (maximal_mu_depth_to 0
                      (pcEvar C) 
                      (pcPattern C))),
   KT := mu_in_evar_path 
           (pcEvar C) (pcPattern C) 0) gpi
wfl: wf []
Himp: Γ ⊢i p <---> q using gpi
Γ ⊢i (C [p]) <---> (C [q]) using gpi unshelve(eapply prf_equiv_congruence); assumption.
  -
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
a: Pattern
l: list Pattern
wfp: well_formed p
wfq: well_formed q
wfC: PC_wf C
gpi: ProofInfo
pile: ProofInfoLe
  (ExGen := list_to_set
              (evar_fresh_seq
                 (free_evars (pcPattern C)
                  ∪ free_evars p ∪ 
                  free_evars q ∪ {[
                  pcEvar C]})
                 (maximal_exists_depth_to 0
                    (pcEvar C) 
                    (pcPattern C))),
   SVSubst := list_to_set
                (svar_fresh_seq
                   (free_svars (pcPattern C)
                    ∪ free_svars p
                    ∪ free_svars q)
                   (maximal_mu_depth_to 0
                      (pcEvar C) 
                      (pcPattern C))),
   KT := mu_in_evar_path 
           (pcEvar C) (pcPattern C) 0) gpi
wfl: wf (a :: l)
Himp: Γ ⊢i p <---> q using gpi
IHl: wf l
→ Γ
  ⊢i foldr patt_imp (C [p]) l <--->
     foldr patt_imp (C [q]) l using gpi
Γ
⊢i (a ---> foldr patt_imp (C [p]) l) <--->
   (a ---> foldr patt_imp (C [q]) l) using gpi pose proof (wfal := wfl).
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
a: Pattern
l: list Pattern
wfp: well_formed p
wfq: well_formed q
wfC: PC_wf C
gpi: ProofInfo
pile: ProofInfoLe
  (ExGen := list_to_set
              (evar_fresh_seq
                 (free_evars (pcPattern C)
                  ∪ free_evars p ∪ 
                  free_evars q ∪ {[
                  pcEvar C]})
                 (maximal_exists_depth_to 0
                    (pcEvar C) 
                    (pcPattern C))),
   SVSubst := list_to_set
                (svar_fresh_seq
                   (free_svars (pcPattern C)
                    ∪ free_svars p
                    ∪ free_svars q)
                   (maximal_mu_depth_to 0
                      (pcEvar C) 
                      (pcPattern C))),
   KT := mu_in_evar_path 
           (pcEvar C) (pcPattern C) 0) gpi
wfl: wf (a :: l)
Himp: Γ ⊢i p <---> q using gpi
IHl: wf l
→ Γ
  ⊢i foldr patt_imp (C [p]) l <--->
     foldr patt_imp (C [q]) l using gpi
wfal: wf (a :: l)
Γ
⊢i (a ---> foldr patt_imp (C [p]) l) <--->
   (a ---> foldr patt_imp (C [q]) l) using gpi
    unfold Pattern.wf in wfl.
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
a: Pattern
l: list Pattern
wfp: well_formed p
wfq: well_formed q
wfC: PC_wf C
gpi: ProofInfo
pile: ProofInfoLe
  (ExGen := list_to_set
              (evar_fresh_seq
                 (free_evars (pcPattern C)
                  ∪ free_evars p ∪ 
                  free_evars q ∪ {[
                  pcEvar C]})
                 (maximal_exists_depth_to 0
                    (pcEvar C) 
                    (pcPattern C))),
   SVSubst := list_to_set
                (svar_fresh_seq
                   (free_svars (pcPattern C)
                    ∪ free_svars p
                    ∪ free_svars q)
                   (maximal_mu_depth_to 0
                      (pcEvar C) 
                      (pcPattern C))),
   KT := mu_in_evar_path 
           (pcEvar C) (pcPattern C) 0) gpi
wfl: foldr andb true (map well_formed (a :: l))
Himp: Γ ⊢i p <---> q using gpi
IHl: wf l
→ Γ
  ⊢i foldr patt_imp (C [p]) l <--->
     foldr patt_imp (C [q]) l using gpi
wfal: wf (a :: l)
Γ
⊢i (a ---> foldr patt_imp (C [p]) l) <--->
   (a ---> foldr patt_imp (C [q]) l) using gpi simpl in wfl.
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
a: Pattern
l: list Pattern
wfp: well_formed p
wfq: well_formed q
wfC: PC_wf C
gpi: ProofInfo
pile: ProofInfoLe
  (ExGen := list_to_set
              (evar_fresh_seq
                 (free_evars (pcPattern C)
                  ∪ free_evars p ∪ 
                  free_evars q ∪ {[
                  pcEvar C]})
                 (maximal_exists_depth_to 0
                    (pcEvar C) 
                    (pcPattern C))),
   SVSubst := list_to_set
                (svar_fresh_seq
                   (free_svars (pcPattern C)
                    ∪ free_svars p
                    ∪ free_svars q)
                   (maximal_mu_depth_to 0
                      (pcEvar C) 
                      (pcPattern C))),
   KT := mu_in_evar_path 
           (pcEvar C) (pcPattern C) 0) gpi
wfl: well_formed a &&
foldr andb true (map well_formed l)
Himp: Γ ⊢i p <---> q using gpi
IHl: wf l
→ Γ
  ⊢i foldr patt_imp (C [p]) l <--->
     foldr patt_imp (C [q]) l using gpi
wfal: wf (a :: l)
Γ
⊢i (a ---> foldr patt_imp (C [p]) l) <--->
   (a ---> foldr patt_imp (C [q]) l) using gpi apply andb_prop in wfl as [wfa wfl].
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
a: Pattern
l: list Pattern
wfp: well_formed p
wfq: well_formed q
wfC: PC_wf C
gpi: ProofInfo
pile: ProofInfoLe
  (ExGen := list_to_set
              (evar_fresh_seq
                 (free_evars (pcPattern C)
                  ∪ free_evars p ∪ 
                  free_evars q ∪ {[
                  pcEvar C]})
                 (maximal_exists_depth_to 0
                    (pcEvar C) 
                    (pcPattern C))),
   SVSubst := list_to_set
                (svar_fresh_seq
                   (free_svars (pcPattern C)
                    ∪ free_svars p
                    ∪ free_svars q)
                   (maximal_mu_depth_to 0
                      (pcEvar C) 
                      (pcPattern C))),
   KT := mu_in_evar_path 
           (pcEvar C) (pcPattern C) 0) gpi
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
Himp: Γ ⊢i p <---> q using gpi
IHl: wf l
→ Γ
  ⊢i foldr patt_imp (C [p]) l <--->
     foldr patt_imp (C [q]) l using gpi
wfal: wf (a :: l)
Γ
⊢i (a ---> foldr patt_imp (C [p]) l) <--->
   (a ---> foldr patt_imp (C [q]) l) using gpi
    specialize (IHl wfl).
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
a: Pattern
l: list Pattern
wfp: well_formed p
wfq: well_formed q
wfC: PC_wf C
gpi: ProofInfo
pile: ProofInfoLe
  (ExGen := list_to_set
              (evar_fresh_seq
                 (free_evars (pcPattern C)
                  ∪ free_evars p ∪ 
                  free_evars q ∪ {[
                  pcEvar C]})
                 (maximal_exists_depth_to 0
                    (pcEvar C) 
                    (pcPattern C))),
   SVSubst := list_to_set
                (svar_fresh_seq
                   (free_svars (pcPattern C)
                    ∪ free_svars p
                    ∪ free_svars q)
                   (maximal_mu_depth_to 0
                      (pcEvar C) 
                      (pcPattern C))),
   KT := mu_in_evar_path 
           (pcEvar C) (pcPattern C) 0) gpi
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
Himp: Γ ⊢i p <---> q using gpi
IHl: Γ
⊢i foldr patt_imp (C [p]) l <--->
   foldr patt_imp (C [q]) l using gpi
wfal: wf (a :: l)
Γ
⊢i (a ---> foldr patt_imp (C [p]) l) <--->
   (a ---> foldr patt_imp (C [q]) l) using gpi
    pose proof (Hwf1 := proved_impl_wf _ _ (proj1_sig IHl)).
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
a: Pattern
l: list Pattern
wfp: well_formed p
wfq: well_formed q
wfC: PC_wf C
gpi: ProofInfo
pile: ProofInfoLe
  (ExGen := list_to_set
              (evar_fresh_seq
                 (free_evars (pcPattern C)
                  ∪ free_evars p ∪ 
                  free_evars q ∪ {[
                  pcEvar C]})
                 (maximal_exists_depth_to 0
                    (pcEvar C) 
                    (pcPattern C))),
   SVSubst := list_to_set
                (svar_fresh_seq
                   (free_svars (pcPattern C)
                    ∪ free_svars p
                    ∪ free_svars q)
                   (maximal_mu_depth_to 0
                      (pcEvar C) 
                      (pcPattern C))),
   KT := mu_in_evar_path 
           (pcEvar C) (pcPattern C) 0) gpi
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
Himp: Γ ⊢i p <---> q using gpi
IHl: Γ
⊢i foldr patt_imp (C [p]) l <--->
   foldr patt_imp (C [q]) l using gpi
wfal: wf (a :: l)
Hwf1: well_formed
  (foldr patt_imp (C [p]) l <--->
   foldr patt_imp (C [q]) l)
Γ
⊢i (a ---> foldr patt_imp (C [p]) l) <--->
   (a ---> foldr patt_imp (C [q]) l) using gpi
    pose proof (Hwf2 := proved_impl_wf _ _ (proj1_sig Himp)).
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
a: Pattern
l: list Pattern
wfp: well_formed p
wfq: well_formed q
wfC: PC_wf C
gpi: ProofInfo
pile: ProofInfoLe
  (ExGen := list_to_set
              (evar_fresh_seq
                 (free_evars (pcPattern C)
                  ∪ free_evars p ∪ 
                  free_evars q ∪ {[
                  pcEvar C]})
                 (maximal_exists_depth_to 0
                    (pcEvar C) 
                    (pcPattern C))),
   SVSubst := list_to_set
                (svar_fresh_seq
                   (free_svars (pcPattern C)
                    ∪ free_svars p
                    ∪ free_svars q)
                   (maximal_mu_depth_to 0
                      (pcEvar C) 
                      (pcPattern C))),
   KT := mu_in_evar_path 
           (pcEvar C) (pcPattern C) 0) gpi
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
Himp: Γ ⊢i p <---> q using gpi
IHl: Γ
⊢i foldr patt_imp (C [p]) l <--->
   foldr patt_imp (C [q]) l using gpi
wfal: wf (a :: l)
Hwf1: well_formed
  (foldr patt_imp (C [p]) l <--->
   foldr patt_imp (C [q]) l)
Hwf2: well_formed (p <---> q)
Γ
⊢i (a ---> foldr patt_imp (C [p]) l) <--->
   (a ---> foldr patt_imp (C [q]) l) using gpi
    assert (well_formed (emplace C p)).
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
a: Pattern
l: list Pattern
wfp: well_formed p
wfq: well_formed q
wfC: PC_wf C
gpi: ProofInfo
pile: ProofInfoLe
  (ExGen := list_to_set
              (evar_fresh_seq
                 (free_evars (pcPattern C)
                  ∪ free_evars p ∪ 
                  free_evars q ∪ {[
                  pcEvar C]})
                 (maximal_exists_depth_to 0
                    (pcEvar C) 
                    (pcPattern C))),
   SVSubst := list_to_set
                (svar_fresh_seq
                   (free_svars (pcPattern C)
                    ∪ free_svars p
                    ∪ free_svars q)
                   (maximal_mu_depth_to 0
                      (pcEvar C) 
                      (pcPattern C))),
   KT := mu_in_evar_path 
           (pcEvar C) (pcPattern C) 0) gpi
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
Himp: Γ ⊢i p <---> q using gpi
IHl: Γ
⊢i foldr patt_imp (C [p]) l <--->
   foldr patt_imp (C [q]) l using gpi
wfal: wf (a :: l)
Hwf1: well_formed
  (foldr patt_imp (C [p]) l <--->
   foldr patt_imp (C [q]) l)
Hwf2: well_formed (p <---> q)
well_formed (C [p])
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
a: Pattern
l: list Pattern
wfp: well_formed p
wfq: well_formed q
wfC: PC_wf C
gpi: ProofInfo
pile: ProofInfoLe
  (ExGen := list_to_set
              (evar_fresh_seq
                 (free_evars (pcPattern C)
                  ∪ free_evars p ∪ 
                  free_evars q ∪ {[
                  pcEvar C]})
                 (maximal_exists_depth_to 0
                    (pcEvar C) 
                    (pcPattern C))),
   SVSubst := list_to_set
                (svar_fresh_seq
                   (free_svars (pcPattern C)
                    ∪ free_svars p
                    ∪ free_svars q)
                   (maximal_mu_depth_to 0
                      (pcEvar C) 
                      (pcPattern C))),
   KT := mu_in_evar_path 
           (pcEvar C) (pcPattern C) 0) gpi
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
Himp: Γ ⊢i p <---> q using gpi
IHl: Γ
⊢i foldr patt_imp (C [p]) l <--->
   foldr patt_imp (C [q]) l using gpi
wfal: wf (a :: l)
Hwf1: well_formed
  (foldr patt_imp (C [p]) l <--->
   foldr patt_imp (C [q]) l)
Hwf2: well_formed (p <---> q)
H: well_formed (C [p])
Γ
⊢i (a ---> foldr patt_imp (C [p]) l) <--->
   (a ---> foldr patt_imp (C [q]) l) using gpi
    {
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
a: Pattern
l: list Pattern
wfp: well_formed p
wfq: well_formed q
wfC: PC_wf C
gpi: ProofInfo
pile: ProofInfoLe
  (ExGen := list_to_set
              (evar_fresh_seq
                 (free_evars (pcPattern C)
                  ∪ free_evars p ∪ 
                  free_evars q ∪ {[
                  pcEvar C]})
                 (maximal_exists_depth_to 0
                    (pcEvar C) 
                    (pcPattern C))),
   SVSubst := list_to_set
                (svar_fresh_seq
                   (free_svars (pcPattern C)
                    ∪ free_svars p
                    ∪ free_svars q)
                   (maximal_mu_depth_to 0
                      (pcEvar C) 
                      (pcPattern C))),
   KT := mu_in_evar_path 
           (pcEvar C) (pcPattern C) 0) gpi
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
Himp: Γ ⊢i p <---> q using gpi
IHl: Γ
⊢i foldr patt_imp (C [p]) l <--->
   foldr patt_imp (C [q]) l using gpi
wfal: wf (a :: l)
Hwf1: well_formed
  (foldr patt_imp (C [p]) l <--->
   foldr patt_imp (C [q]) l)
Hwf2: well_formed (p <---> q)
well_formed (C [p])
      unfold emplace.
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
a: Pattern
l: list Pattern
wfp: well_formed p
wfq: well_formed q
wfC: PC_wf C
gpi: ProofInfo
pile: ProofInfoLe
  (ExGen := list_to_set
              (evar_fresh_seq
                 (free_evars (pcPattern C)
                  ∪ free_evars p ∪ 
                  free_evars q ∪ {[
                  pcEvar C]})
                 (maximal_exists_depth_to 0
                    (pcEvar C) 
                    (pcPattern C))),
   SVSubst := list_to_set
                (svar_fresh_seq
                   (free_svars (pcPattern C)
                    ∪ free_svars p
                    ∪ free_svars q)
                   (maximal_mu_depth_to 0
                      (pcEvar C) 
                      (pcPattern C))),
   KT := mu_in_evar_path 
           (pcEvar C) (pcPattern C) 0) gpi
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
Himp: Γ ⊢i p <---> q using gpi
IHl: Γ
⊢i foldr patt_imp (C [p]) l <--->
   foldr patt_imp (C [q]) l using gpi
wfal: wf (a :: l)
Hwf1: well_formed
  (foldr patt_imp (C [p]) l <--->
   foldr patt_imp (C [q]) l)
Hwf2: well_formed (p <---> q)
well_formed (pcPattern C)^[[evar:pcEvar C↦p]]
      wf_auto2.
    }
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
a: Pattern
l: list Pattern
wfp: well_formed p
wfq: well_formed q
wfC: PC_wf C
gpi: ProofInfo
pile: ProofInfoLe
  (ExGen := list_to_set
              (evar_fresh_seq
                 (free_evars (pcPattern C)
                  ∪ free_evars p ∪ 
                  free_evars q ∪ {[
                  pcEvar C]})
                 (maximal_exists_depth_to 0
                    (pcEvar C) 
                    (pcPattern C))),
   SVSubst := list_to_set
                (svar_fresh_seq
                   (free_svars (pcPattern C)
                    ∪ free_svars p
                    ∪ free_svars q)
                   (maximal_mu_depth_to 0
                      (pcEvar C) 
                      (pcPattern C))),
   KT := mu_in_evar_path 
           (pcEvar C) (pcPattern C) 0) gpi
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
Himp: Γ ⊢i p <---> q using gpi
IHl: Γ
⊢i foldr patt_imp (C [p]) l <--->
   foldr patt_imp (C [q]) l using gpi
wfal: wf (a :: l)
Hwf1: well_formed
  (foldr patt_imp (C [p]) l <--->
   foldr patt_imp (C [q]) l)
Hwf2: well_formed (p <---> q)
H: well_formed (C [p])
Γ
⊢i (a ---> foldr patt_imp (C [p]) l) <--->
   (a ---> foldr patt_imp (C [q]) l) using gpi
    assert (well_formed (emplace C q)).
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
a: Pattern
l: list Pattern
wfp: well_formed p
wfq: well_formed q
wfC: PC_wf C
gpi: ProofInfo
pile: ProofInfoLe
  (ExGen := list_to_set
              (evar_fresh_seq
                 (free_evars (pcPattern C)
                  ∪ free_evars p ∪ 
                  free_evars q ∪ {[
                  pcEvar C]})
                 (maximal_exists_depth_to 0
                    (pcEvar C) 
                    (pcPattern C))),
   SVSubst := list_to_set
                (svar_fresh_seq
                   (free_svars (pcPattern C)
                    ∪ free_svars p
                    ∪ free_svars q)
                   (maximal_mu_depth_to 0
                      (pcEvar C) 
                      (pcPattern C))),
   KT := mu_in_evar_path 
           (pcEvar C) (pcPattern C) 0) gpi
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
Himp: Γ ⊢i p <---> q using gpi
IHl: Γ
⊢i foldr patt_imp (C [p]) l <--->
   foldr patt_imp (C [q]) l using gpi
wfal: wf (a :: l)
Hwf1: well_formed
  (foldr patt_imp (C [p]) l <--->
   foldr patt_imp (C [q]) l)
Hwf2: well_formed (p <---> q)
H: well_formed (C [p])
well_formed (C [q])
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
a: Pattern
l: list Pattern
wfp: well_formed p
wfq: well_formed q
wfC: PC_wf C
gpi: ProofInfo
pile: ProofInfoLe
  (ExGen := list_to_set
              (evar_fresh_seq
                 (free_evars (pcPattern C)
                  ∪ free_evars p ∪ 
                  free_evars q ∪ {[
                  pcEvar C]})
                 (maximal_exists_depth_to 0
                    (pcEvar C) 
                    (pcPattern C))),
   SVSubst := list_to_set
                (svar_fresh_seq
                   (free_svars (pcPattern C)
                    ∪ free_svars p
                    ∪ free_svars q)
                   (maximal_mu_depth_to 0
                      (pcEvar C) 
                      (pcPattern C))),
   KT := mu_in_evar_path 
           (pcEvar C) (pcPattern C) 0) gpi
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
Himp: Γ ⊢i p <---> q using gpi
IHl: Γ
⊢i foldr patt_imp (C [p]) l <--->
   foldr patt_imp (C [q]) l using gpi
wfal: wf (a :: l)
Hwf1: well_formed
  (foldr patt_imp (C [p]) l <--->
   foldr patt_imp (C [q]) l)
Hwf2: well_formed (p <---> q)
H: well_formed (C [p])
H0: well_formed (C [q])
Γ
⊢i (a ---> foldr patt_imp (C [p]) l) <--->
   (a ---> foldr patt_imp (C [q]) l) using gpi
    {
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
a: Pattern
l: list Pattern
wfp: well_formed p
wfq: well_formed q
wfC: PC_wf C
gpi: ProofInfo
pile: ProofInfoLe
  (ExGen := list_to_set
              (evar_fresh_seq
                 (free_evars (pcPattern C)
                  ∪ free_evars p ∪ 
                  free_evars q ∪ {[
                  pcEvar C]})
                 (maximal_exists_depth_to 0
                    (pcEvar C) 
                    (pcPattern C))),
   SVSubst := list_to_set
                (svar_fresh_seq
                   (free_svars (pcPattern C)
                    ∪ free_svars p
                    ∪ free_svars q)
                   (maximal_mu_depth_to 0
                      (pcEvar C) 
                      (pcPattern C))),
   KT := mu_in_evar_path 
           (pcEvar C) (pcPattern C) 0) gpi
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
Himp: Γ ⊢i p <---> q using gpi
IHl: Γ
⊢i foldr patt_imp (C [p]) l <--->
   foldr patt_imp (C [q]) l using gpi
wfal: wf (a :: l)
Hwf1: well_formed
  (foldr patt_imp (C [p]) l <--->
   foldr patt_imp (C [q]) l)
Hwf2: well_formed (p <---> q)
H: well_formed (C [p])
well_formed (C [q])
      unfold emplace.
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
a: Pattern
l: list Pattern
wfp: well_formed p
wfq: well_formed q
wfC: PC_wf C
gpi: ProofInfo
pile: ProofInfoLe
  (ExGen := list_to_set
              (evar_fresh_seq
                 (free_evars (pcPattern C)
                  ∪ free_evars p ∪ 
                  free_evars q ∪ {[
                  pcEvar C]})
                 (maximal_exists_depth_to 0
                    (pcEvar C) 
                    (pcPattern C))),
   SVSubst := list_to_set
                (svar_fresh_seq
                   (free_svars (pcPattern C)
                    ∪ free_svars p
                    ∪ free_svars q)
                   (maximal_mu_depth_to 0
                      (pcEvar C) 
                      (pcPattern C))),
   KT := mu_in_evar_path 
           (pcEvar C) (pcPattern C) 0) gpi
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
Himp: Γ ⊢i p <---> q using gpi
IHl: Γ
⊢i foldr patt_imp (C [p]) l <--->
   foldr patt_imp (C [q]) l using gpi
wfal: wf (a :: l)
Hwf1: well_formed
  (foldr patt_imp (C [p]) l <--->
   foldr patt_imp (C [q]) l)
Hwf2: well_formed (p <---> q)
H: well_formed (C [p])
well_formed (pcPattern C)^[[evar:pcEvar C↦q]]
      wf_auto2.
    }
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
a: Pattern
l: list Pattern
wfp: well_formed p
wfq: well_formed q
wfC: PC_wf C
gpi: ProofInfo
pile: ProofInfoLe
  (ExGen := list_to_set
              (evar_fresh_seq
                 (free_evars (pcPattern C)
                  ∪ free_evars p ∪ 
                  free_evars q ∪ {[
                  pcEvar C]})
                 (maximal_exists_depth_to 0
                    (pcEvar C) 
                    (pcPattern C))),
   SVSubst := list_to_set
                (svar_fresh_seq
                   (free_svars (pcPattern C)
                    ∪ free_svars p
                    ∪ free_svars q)
                   (maximal_mu_depth_to 0
                      (pcEvar C) 
                      (pcPattern C))),
   KT := mu_in_evar_path 
           (pcEvar C) (pcPattern C) 0) gpi
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
Himp: Γ ⊢i p <---> q using gpi
IHl: Γ
⊢i foldr patt_imp (C [p]) l <--->
   foldr patt_imp (C [q]) l using gpi
wfal: wf (a :: l)
Hwf1: well_formed
  (foldr patt_imp (C [p]) l <--->
   foldr patt_imp (C [q]) l)
Hwf2: well_formed (p <---> q)
H: well_formed (C [p])
H0: well_formed (C [q])
Γ
⊢i (a ---> foldr patt_imp (C [p]) l) <--->
   (a ---> foldr patt_imp (C [q]) l) using gpi
    toMLGoal.
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
a: Pattern
l: list Pattern
wfp: well_formed p
wfq: well_formed q
wfC: PC_wf C
gpi: ProofInfo
pile: ProofInfoLe
  (ExGen := list_to_set
              (evar_fresh_seq
                 (free_evars (pcPattern C)
                  ∪ free_evars p ∪ 
                  free_evars q ∪ {[
                  pcEvar C]})
                 (maximal_exists_depth_to 0
                    (pcEvar C) 
                    (pcPattern C))),
   SVSubst := list_to_set
                (svar_fresh_seq
                   (free_svars (pcPattern C)
                    ∪ free_svars p
                    ∪ free_svars q)
                   (maximal_mu_depth_to 0
                      (pcEvar C) 
                      (pcPattern C))),
   KT := mu_in_evar_path 
           (pcEvar C) (pcPattern C) 0) gpi
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
Himp: Γ ⊢i p <---> q using gpi
IHl: Γ
⊢i foldr patt_imp (C [p]) l <--->
   foldr patt_imp (C [q]) l using gpi
wfal: wf (a :: l)
Hwf1: well_formed
  (foldr patt_imp (C [p]) l <--->
   foldr patt_imp (C [q]) l)
Hwf2: well_formed (p <---> q)
H: well_formed (C [p])
H0: well_formed (C [q])
well_formed
  ((a ---> foldr patt_imp (C [p]) l) <--->
   (a ---> foldr patt_imp (C [q]) l))
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
a: Pattern
l: list Pattern
wfp: well_formed p
wfq: well_formed q
wfC: PC_wf C
gpi: ProofInfo
pile: ProofInfoLe
  (ExGen := list_to_set
              (evar_fresh_seq
                 (free_evars (pcPattern C)
                  ∪ free_evars p ∪ 
                  free_evars q ∪ {[
                  pcEvar C]})
                 (maximal_exists_depth_to 0
                    (pcEvar C) 
                    (pcPattern C))),
   SVSubst := list_to_set
                (svar_fresh_seq
                   (free_svars (pcPattern C)
                    ∪ free_svars p
                    ∪ free_svars q)
                   (maximal_mu_depth_to 0
                      (pcEvar C) 
                      (pcPattern C))),
   KT := mu_in_evar_path 
           (pcEvar C) (pcPattern C) 0) gpi
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
Himp: Γ ⊢i p <---> q using gpi
IHl: Γ
⊢i foldr patt_imp (C [p]) l <--->
   foldr patt_imp (C [q]) l using gpi
wfal: wf (a :: l)
Hwf1: well_formed
  (foldr patt_imp (C [p]) l <--->
   foldr patt_imp (C [q]) l)
Hwf2: well_formed (p <---> q)
H: well_formed (C [p])
H0: well_formed (C [q])
Γ Ⱶ
(a ---> foldr patt_imp (C [p]) l) <--->
(a ---> foldr patt_imp (C [q]) l)
using gpi

    {
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
a: Pattern
l: list Pattern
wfp: well_formed p
wfq: well_formed q
wfC: PC_wf C
gpi: ProofInfo
pile: ProofInfoLe
  (ExGen := list_to_set
              (evar_fresh_seq
                 (free_evars (pcPattern C)
                  ∪ free_evars p ∪ 
                  free_evars q ∪ {[
                  pcEvar C]})
                 (maximal_exists_depth_to 0
                    (pcEvar C) 
                    (pcPattern C))),
   SVSubst := list_to_set
                (svar_fresh_seq
                   (free_svars (pcPattern C)
                    ∪ free_svars p
                    ∪ free_svars q)
                   (maximal_mu_depth_to 0
                      (pcEvar C) 
                      (pcPattern C))),
   KT := mu_in_evar_path 
           (pcEvar C) (pcPattern C) 0) gpi
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
Himp: Γ ⊢i p <---> q using gpi
IHl: Γ
⊢i foldr patt_imp (C [p]) l <--->
   foldr patt_imp (C [q]) l using gpi
wfal: wf (a :: l)
Hwf1: well_formed
  (foldr patt_imp (C [p]) l <--->
   foldr patt_imp (C [q]) l)
Hwf2: well_formed (p <---> q)
H: well_formed (C [p])
H0: well_formed (C [q])
well_formed
  ((a ---> foldr patt_imp (C [p]) l) <--->
   (a ---> foldr patt_imp (C [q]) l)) unfold emplace.
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
a: Pattern
l: list Pattern
wfp: well_formed p
wfq: well_formed q
wfC: PC_wf C
gpi: ProofInfo
pile: ProofInfoLe
  (ExGen := list_to_set
              (evar_fresh_seq
                 (free_evars (pcPattern C)
                  ∪ free_evars p ∪ 
                  free_evars q ∪ {[
                  pcEvar C]})
                 (maximal_exists_depth_to 0
                    (pcEvar C) 
                    (pcPattern C))),
   SVSubst := list_to_set
                (svar_fresh_seq
                   (free_svars (pcPattern C)
                    ∪ free_svars p
                    ∪ free_svars q)
                   (maximal_mu_depth_to 0
                      (pcEvar C) 
                      (pcPattern C))),
   KT := mu_in_evar_path 
           (pcEvar C) (pcPattern C) 0) gpi
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
Himp: Γ ⊢i p <---> q using gpi
IHl: Γ
⊢i foldr patt_imp (C [p]) l <--->
   foldr patt_imp (C [q]) l using gpi
wfal: wf (a :: l)
Hwf1: well_formed
  (foldr patt_imp (C [p]) l <--->
   foldr patt_imp (C [q]) l)
Hwf2: well_formed (p <---> q)
H: well_formed (C [p])
H0: well_formed (C [q])
well_formed
  ((a --->
    foldr patt_imp (pcPattern C)^[[evar:pcEvar C↦p]] l) <--->
   (a --->
    foldr patt_imp (pcPattern C)^[[evar:pcEvar C↦q]] l)) wf_auto2. }
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
a: Pattern
l: list Pattern
wfp: well_formed p
wfq: well_formed q
wfC: PC_wf C
gpi: ProofInfo
pile: ProofInfoLe
  (ExGen := list_to_set
              (evar_fresh_seq
                 (free_evars (pcPattern C)
                  ∪ free_evars p ∪ 
                  free_evars q ∪ {[
                  pcEvar C]})
                 (maximal_exists_depth_to 0
                    (pcEvar C) 
                    (pcPattern C))),
   SVSubst := list_to_set
                (svar_fresh_seq
                   (free_svars (pcPattern C)
                    ∪ free_svars p
                    ∪ free_svars q)
                   (maximal_mu_depth_to 0
                      (pcEvar C) 
                      (pcPattern C))),
   KT := mu_in_evar_path 
           (pcEvar C) (pcPattern C) 0) gpi
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
Himp: Γ ⊢i p <---> q using gpi
IHl: Γ
⊢i foldr patt_imp (C [p]) l <--->
   foldr patt_imp (C [q]) l using gpi
wfal: wf (a :: l)
Hwf1: well_formed
  (foldr patt_imp (C [p]) l <--->
   foldr patt_imp (C [q]) l)
Hwf2: well_formed (p <---> q)
H: well_formed (C [p])
H0: well_formed (C [q])
Γ Ⱶ
(a ---> foldr patt_imp (C [p]) l) <--->
(a ---> foldr patt_imp (C [q]) l)
using gpi

    unfold patt_iff.
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
a: Pattern
l: list Pattern
wfp: well_formed p
wfq: well_formed q
wfC: PC_wf C
gpi: ProofInfo
pile: ProofInfoLe
  (ExGen := list_to_set
              (evar_fresh_seq
                 (free_evars (pcPattern C)
                  ∪ free_evars p ∪ 
                  free_evars q ∪ {[
                  pcEvar C]})
                 (maximal_exists_depth_to 0
                    (pcEvar C) 
                    (pcPattern C))),
   SVSubst := list_to_set
                (svar_fresh_seq
                   (free_svars (pcPattern C)
                    ∪ free_svars p
                    ∪ free_svars q)
                   (maximal_mu_depth_to 0
                      (pcEvar C) 
                      (pcPattern C))),
   KT := mu_in_evar_path 
           (pcEvar C) (pcPattern C) 0) gpi
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
Himp: Γ ⊢i p <---> q using gpi
IHl: Γ
⊢i foldr patt_imp (C [p]) l <--->
   foldr patt_imp (C [q]) l using gpi
wfal: wf (a :: l)
Hwf1: well_formed
  (foldr patt_imp (C [p]) l <--->
   foldr patt_imp (C [q]) l)
Hwf2: well_formed (p <---> q)
H: well_formed (C [p])
H0: well_formed (C [q])
Γ Ⱶ
((a ---> foldr patt_imp (C [p]) l) --->
 a ---> foldr patt_imp (C [q]) l)
and ((a ---> foldr patt_imp (C [q]) l) --->
     a ---> foldr patt_imp (C [p]) l)
using gpi

    mlSplitAnd.
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
a: Pattern
l: list Pattern
wfp: well_formed p
wfq: well_formed q
wfC: PC_wf C
gpi: ProofInfo
pile: ProofInfoLe
  (ExGen := list_to_set
              (evar_fresh_seq
                 (free_evars (pcPattern C)
                  ∪ free_evars p ∪ 
                  free_evars q ∪ {[
                  pcEvar C]})
                 (maximal_exists_depth_to 0
                    (pcEvar C) 
                    (pcPattern C))),
   SVSubst := list_to_set
                (svar_fresh_seq
                   (free_svars (pcPattern C)
                    ∪ free_svars p
                    ∪ free_svars q)
                   (maximal_mu_depth_to 0
                      (pcEvar C) 
                      (pcPattern C))),
   KT := mu_in_evar_path 
           (pcEvar C) (pcPattern C) 0) gpi
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
Himp: Γ ⊢i p <---> q using gpi
IHl: Γ
⊢i foldr patt_imp (C [p]) l <--->
   foldr patt_imp (C [q]) l using gpi
wfal: wf (a :: l)
Hwf1: well_formed
  (foldr patt_imp (C [p]) l <--->
   foldr patt_imp (C [q]) l)
Hwf2: well_formed (p <---> q)
H: well_formed (C [p])
H0: well_formed (C [q])
Γ Ⱶ
(a ---> foldr patt_imp (C [p]) l) --->
a ---> foldr patt_imp (C [q]) l
using gpi
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
a: Pattern
l: list Pattern
wfp: well_formed p
wfq: well_formed q
wfC: PC_wf C
gpi: ProofInfo
pile: ProofInfoLe
  (ExGen := list_to_set
              (evar_fresh_seq
                 (free_evars (pcPattern C)
                  ∪ free_evars p ∪ 
                  free_evars q ∪ {[
                  pcEvar C]})
                 (maximal_exists_depth_to 0
                    (pcEvar C) 
                    (pcPattern C))),
   SVSubst := list_to_set
                (svar_fresh_seq
                   (free_svars (pcPattern C)
                    ∪ free_svars p
                    ∪ free_svars q)
                   (maximal_mu_depth_to 0
                      (pcEvar C) 
                      (pcPattern C))),
   KT := mu_in_evar_path 
           (pcEvar C) (pcPattern C) 0) gpi
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
Himp: Γ ⊢i p <---> q using gpi
IHl: Γ
⊢i foldr patt_imp (C [p]) l <--->
   foldr patt_imp (C [q]) l using gpi
wfal: wf (a :: l)
Hwf1: well_formed
  (foldr patt_imp (C [p]) l <--->
   foldr patt_imp (C [q]) l)
Hwf2: well_formed (p <---> q)
H: well_formed (C [p])
H0: well_formed (C [q])
Γ Ⱶ
(a ---> foldr patt_imp (C [q]) l) --->
a ---> foldr patt_imp (C [p]) l
using gpi

    +
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
a: Pattern
l: list Pattern
wfp: well_formed p
wfq: well_formed q
wfC: PC_wf C
gpi: ProofInfo
pile: ProofInfoLe
  (ExGen := list_to_set
              (evar_fresh_seq
                 (free_evars (pcPattern C)
                  ∪ free_evars p ∪ 
                  free_evars q ∪ {[
                  pcEvar C]})
                 (maximal_exists_depth_to 0
                    (pcEvar C) 
                    (pcPattern C))),
   SVSubst := list_to_set
                (svar_fresh_seq
                   (free_svars (pcPattern C)
                    ∪ free_svars p
                    ∪ free_svars q)
                   (maximal_mu_depth_to 0
                      (pcEvar C) 
                      (pcPattern C))),
   KT := mu_in_evar_path 
           (pcEvar C) (pcPattern C) 0) gpi
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
Himp: Γ ⊢i p <---> q using gpi
IHl: Γ
⊢i foldr patt_imp (C [p]) l <--->
   foldr patt_imp (C [q]) l using gpi
wfal: wf (a :: l)
Hwf1: well_formed
  (foldr patt_imp (C [p]) l <--->
   foldr patt_imp (C [q]) l)
Hwf2: well_formed (p <---> q)
H: well_formed (C [p])
H0: well_formed (C [q])
Γ Ⱶ
(a ---> foldr patt_imp (C [p]) l) --->
a ---> foldr patt_imp (C [q]) l
using gpi
 mlIntro.
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
a: Pattern
l: list Pattern
wfp: well_formed p
wfq: well_formed q
wfC: PC_wf C
gpi: ProofInfo
pile: ProofInfoLe
  (ExGen := list_to_set
              (evar_fresh_seq
                 (free_evars (pcPattern C)
                  ∪ free_evars p ∪ 
                  free_evars q ∪ {[
                  pcEvar C]})
                 (maximal_exists_depth_to 0
                    (pcEvar C) 
                    (pcPattern C))),
   SVSubst := list_to_set
                (svar_fresh_seq
                   (free_svars (pcPattern C)
                    ∪ free_svars p
                    ∪ free_svars q)
                   (maximal_mu_depth_to 0
                      (pcEvar C) 
                      (pcPattern C))),
   KT := mu_in_evar_path 
           (pcEvar C) (pcPattern C) 0) gpi
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
Himp: Γ ⊢i p <---> q using gpi
IHl: Γ
⊢i foldr patt_imp (C [p]) l <--->
   foldr patt_imp (C [q]) l using gpi
wfal: wf (a :: l)
Hwf1: well_formed
  (foldr patt_imp (C [p]) l <--->
   foldr patt_imp (C [q]) l)
Hwf2: well_formed (p <---> q)
H: well_formed (C [p])
H0: well_formed (C [q])
Γ Ⱶ
"0" ∶ a ---> foldr patt_imp (C [p]) l,
--------------------------------------
a ---> foldr patt_imp (C [q]) l
using gpi
 mlIntro.
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
a: Pattern
l: list Pattern
wfp: well_formed p
wfq: well_formed q
wfC: PC_wf C
gpi: ProofInfo
pile: ProofInfoLe
  (ExGen := list_to_set
              (evar_fresh_seq
                 (free_evars (pcPattern C)
                  ∪ free_evars p ∪ 
                  free_evars q ∪ {[
                  pcEvar C]})
                 (maximal_exists_depth_to 0
                    (pcEvar C) 
                    (pcPattern C))),
   SVSubst := list_to_set
                (svar_fresh_seq
                   (free_svars (pcPattern C)
                    ∪ free_svars p
                    ∪ free_svars q)
                   (maximal_mu_depth_to 0
                      (pcEvar C) 
                      (pcPattern C))),
   KT := mu_in_evar_path 
           (pcEvar C) (pcPattern C) 0) gpi
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
Himp: Γ ⊢i p <---> q using gpi
IHl: Γ
⊢i foldr patt_imp (C [p]) l <--->
   foldr patt_imp (C [q]) l using gpi
wfal: wf (a :: l)
Hwf1: well_formed
  (foldr patt_imp (C [p]) l <--->
   foldr patt_imp (C [q]) l)
Hwf2: well_formed (p <---> q)
H: well_formed (C [p])
H0: well_formed (C [q])
Γ Ⱶ
"0" ∶ a ---> foldr patt_imp (C [p]) l,
"1" ∶ a,
--------------------------------------
foldr patt_imp (C [q]) l
using gpi

      mlAssert ((foldr patt_imp (emplace C p) l)).
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
a: Pattern
l: list Pattern
wfp: well_formed p
wfq: well_formed q
wfC: PC_wf C
gpi: ProofInfo
pile: ProofInfoLe
  (ExGen := list_to_set
              (evar_fresh_seq
                 (free_evars (pcPattern C)
                  ∪ free_evars p ∪ 
                  free_evars q ∪ {[
                  pcEvar C]})
                 (maximal_exists_depth_to 0
                    (pcEvar C) 
                    (pcPattern C))),
   SVSubst := list_to_set
                (svar_fresh_seq
                   (free_svars (pcPattern C)
                    ∪ free_svars p
                    ∪ free_svars q)
                   (maximal_mu_depth_to 0
                      (pcEvar C) 
                      (pcPattern C))),
   KT := mu_in_evar_path 
           (pcEvar C) (pcPattern C) 0) gpi
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
Himp: Γ ⊢i p <---> q using gpi
IHl: Γ
⊢i foldr patt_imp (C [p]) l <--->
   foldr patt_imp (C [q]) l using gpi
wfal: wf (a :: l)
Hwf1: well_formed
  (foldr patt_imp (C [p]) l <--->
   foldr patt_imp (C [q]) l)
Hwf2: well_formed (p <---> q)
H: well_formed (C [p])
H0: well_formed (C [q])
well_formed (foldr patt_imp (C [p]) l)
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
a: Pattern
l: list Pattern
wfp: well_formed p
wfq: well_formed q
wfC: PC_wf C
gpi: ProofInfo
pile: ProofInfoLe
  (ExGen := list_to_set
              (evar_fresh_seq
                 (free_evars (pcPattern C)
                  ∪ free_evars p ∪ 
                  free_evars q ∪ {[
                  pcEvar C]})
                 (maximal_exists_depth_to 0
                    (pcEvar C) 
                    (pcPattern C))),
   SVSubst := list_to_set
                (svar_fresh_seq
                   (free_svars (pcPattern C)
                    ∪ free_svars p
                    ∪ free_svars q)
                   (maximal_mu_depth_to 0
                      (pcEvar C) 
                      (pcPattern C))),
   KT := mu_in_evar_path 
           (pcEvar C) (pcPattern C) 0) gpi
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
Himp: Γ ⊢i p <---> q using gpi
IHl: Γ
⊢i foldr patt_imp (C [p]) l <--->
   foldr patt_imp (C [q]) l using gpi
wfal: wf (a :: l)
Hwf1: well_formed
  (foldr patt_imp (C [p]) l <--->
   foldr patt_imp (C [q]) l)
Hwf2: well_formed (p <---> q)
H: well_formed (C [p])
H0: well_formed (C [q])
Hwf: well_formed (foldr patt_imp (C [p]) l)
Γ Ⱶ
"0" ∶ a ---> foldr patt_imp (C [p]) l,
"1" ∶ a,
--------------------------------------
foldr patt_imp (C [p]) l
using gpi
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
a: Pattern
l: list Pattern
wfp: well_formed p
wfq: well_formed q
wfC: PC_wf C
gpi: ProofInfo
pile: ProofInfoLe
  (ExGen := list_to_set
              (evar_fresh_seq
                 (free_evars (pcPattern C)
                  ∪ free_evars p ∪ 
                  free_evars q ∪ {[
                  pcEvar C]})
                 (maximal_exists_depth_to 0
                    (pcEvar C) 
                    (pcPattern C))),
   SVSubst := list_to_set
                (svar_fresh_seq
                   (free_svars (pcPattern C)
                    ∪ free_svars p
                    ∪ free_svars q)
                   (maximal_mu_depth_to 0
                      (pcEvar C) 
                      (pcPattern C))),
   KT := mu_in_evar_path 
           (pcEvar C) (pcPattern C) 0) gpi
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
Himp: Γ ⊢i p <---> q using gpi
IHl: Γ
⊢i foldr patt_imp (C [p]) l <--->
   foldr patt_imp (C [q]) l using gpi
wfal: wf (a :: l)
Hwf1: well_formed
  (foldr patt_imp (C [p]) l <--->
   foldr patt_imp (C [q]) l)
Hwf2: well_formed (p <---> q)
H: well_formed (C [p])
H0: well_formed (C [q])
Hwf: well_formed (foldr patt_imp (C [p]) l)
Γ Ⱶ
"0" ∶ a ---> foldr patt_imp (C [p]) l,
"1" ∶ a,
"2" ∶ foldr patt_imp (C [p]) l,
--------------------------------------
foldr patt_imp (C [q]) l
using gpi

      {
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
a: Pattern
l: list Pattern
wfp: well_formed p
wfq: well_formed q
wfC: PC_wf C
gpi: ProofInfo
pile: ProofInfoLe
  (ExGen := list_to_set
              (evar_fresh_seq
                 (free_evars (pcPattern C)
                  ∪ free_evars p ∪ 
                  free_evars q ∪ {[
                  pcEvar C]})
                 (maximal_exists_depth_to 0
                    (pcEvar C) 
                    (pcPattern C))),
   SVSubst := list_to_set
                (svar_fresh_seq
                   (free_svars (pcPattern C)
                    ∪ free_svars p
                    ∪ free_svars q)
                   (maximal_mu_depth_to 0
                      (pcEvar C) 
                      (pcPattern C))),
   KT := mu_in_evar_path 
           (pcEvar C) (pcPattern C) 0) gpi
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
Himp: Γ ⊢i p <---> q using gpi
IHl: Γ
⊢i foldr patt_imp (C [p]) l <--->
   foldr patt_imp (C [q]) l using gpi
wfal: wf (a :: l)
Hwf1: well_formed
  (foldr patt_imp (C [p]) l <--->
   foldr patt_imp (C [q]) l)
Hwf2: well_formed (p <---> q)
H: well_formed (C [p])
H0: well_formed (C [q])
well_formed (foldr patt_imp (C [p]) l) wf_auto2. }
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
a: Pattern
l: list Pattern
wfp: well_formed p
wfq: well_formed q
wfC: PC_wf C
gpi: ProofInfo
pile: ProofInfoLe
  (ExGen := list_to_set
              (evar_fresh_seq
                 (free_evars (pcPattern C)
                  ∪ free_evars p ∪ 
                  free_evars q ∪ {[
                  pcEvar C]})
                 (maximal_exists_depth_to 0
                    (pcEvar C) 
                    (pcPattern C))),
   SVSubst := list_to_set
                (svar_fresh_seq
                   (free_svars (pcPattern C)
                    ∪ free_svars p
                    ∪ free_svars q)
                   (maximal_mu_depth_to 0
                      (pcEvar C) 
                      (pcPattern C))),
   KT := mu_in_evar_path 
           (pcEvar C) (pcPattern C) 0) gpi
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
Himp: Γ ⊢i p <---> q using gpi
IHl: Γ
⊢i foldr patt_imp (C [p]) l <--->
   foldr patt_imp (C [q]) l using gpi
wfal: wf (a :: l)
Hwf1: well_formed
  (foldr patt_imp (C [p]) l <--->
   foldr patt_imp (C [q]) l)
Hwf2: well_formed (p <---> q)
H: well_formed (C [p])
H0: well_formed (C [q])
Hwf: well_formed (foldr patt_imp (C [p]) l)
Γ Ⱶ
"0" ∶ a ---> foldr patt_imp (C [p]) l,
"1" ∶ a,
--------------------------------------
foldr patt_imp (C [p]) l
using gpi
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
a: Pattern
l: list Pattern
wfp: well_formed p
wfq: well_formed q
wfC: PC_wf C
gpi: ProofInfo
pile: ProofInfoLe
  (ExGen := list_to_set
              (evar_fresh_seq
                 (free_evars (pcPattern C)
                  ∪ free_evars p ∪ 
                  free_evars q ∪ {[
                  pcEvar C]})
                 (maximal_exists_depth_to 0
                    (pcEvar C) 
                    (pcPattern C))),
   SVSubst := list_to_set
                (svar_fresh_seq
                   (free_svars (pcPattern C)
                    ∪ free_svars p
                    ∪ free_svars q)
                   (maximal_mu_depth_to 0
                      (pcEvar C) 
                      (pcPattern C))),
   KT := mu_in_evar_path 
           (pcEvar C) (pcPattern C) 0) gpi
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
Himp: Γ ⊢i p <---> q using gpi
IHl: Γ
⊢i foldr patt_imp (C [p]) l <--->
   foldr patt_imp (C [q]) l using gpi
wfal: wf (a :: l)
Hwf1: well_formed
  (foldr patt_imp (C [p]) l <--->
   foldr patt_imp (C [q]) l)
Hwf2: well_formed (p <---> q)
H: well_formed (C [p])
H0: well_formed (C [q])
Hwf: well_formed (foldr patt_imp (C [p]) l)
Γ Ⱶ
"0" ∶ a ---> foldr patt_imp (C [p]) l,
"1" ∶ a,
"2" ∶ foldr patt_imp (C [p]) l,
--------------------------------------
foldr patt_imp (C [q]) l
using gpi

      {
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
a: Pattern
l: list Pattern
wfp: well_formed p
wfq: well_formed q
wfC: PC_wf C
gpi: ProofInfo
pile: ProofInfoLe
  (ExGen := list_to_set
              (evar_fresh_seq
                 (free_evars (pcPattern C)
                  ∪ free_evars p ∪ 
                  free_evars q ∪ {[
                  pcEvar C]})
                 (maximal_exists_depth_to 0
                    (pcEvar C) 
                    (pcPattern C))),
   SVSubst := list_to_set
                (svar_fresh_seq
                   (free_svars (pcPattern C)
                    ∪ free_svars p
                    ∪ free_svars q)
                   (maximal_mu_depth_to 0
                      (pcEvar C) 
                      (pcPattern C))),
   KT := mu_in_evar_path 
           (pcEvar C) (pcPattern C) 0) gpi
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
Himp: Γ ⊢i p <---> q using gpi
IHl: Γ
⊢i foldr patt_imp (C [p]) l <--->
   foldr patt_imp (C [q]) l using gpi
wfal: wf (a :: l)
Hwf1: well_formed
  (foldr patt_imp (C [p]) l <--->
   foldr patt_imp (C [q]) l)
Hwf2: well_formed (p <---> q)
H: well_formed (C [p])
H0: well_formed (C [q])
Hwf: well_formed (foldr patt_imp (C [p]) l)
Γ Ⱶ
"0" ∶ a ---> foldr patt_imp (C [p]) l,
"1" ∶ a,
--------------------------------------
foldr patt_imp (C [p]) l
using gpi
 mlApply "0".
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
a: Pattern
l: list Pattern
wfp: well_formed p
wfq: well_formed q
wfC: PC_wf C
gpi: ProofInfo
pile: ProofInfoLe
  (ExGen := list_to_set
              (evar_fresh_seq
                 (free_evars (pcPattern C)
                  ∪ free_evars p ∪ 
                  free_evars q ∪ {[
                  pcEvar C]})
                 (maximal_exists_depth_to 0
                    (pcEvar C) 
                    (pcPattern C))),
   SVSubst := list_to_set
                (svar_fresh_seq
                   (free_svars (pcPattern C)
                    ∪ free_svars p
                    ∪ free_svars q)
                   (maximal_mu_depth_to 0
                      (pcEvar C) 
                      (pcPattern C))),
   KT := mu_in_evar_path 
           (pcEvar C) (pcPattern C) 0) gpi
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
Himp: Γ ⊢i p <---> q using gpi
IHl: Γ
⊢i foldr patt_imp (C [p]) l <--->
   foldr patt_imp (C [q]) l using gpi
wfal: wf (a :: l)
Hwf1: well_formed
  (foldr patt_imp (C [p]) l <--->
   foldr patt_imp (C [q]) l)
Hwf2: well_formed (p <---> q)
H: well_formed (C [p])
H0: well_formed (C [q])
Hwf: well_formed (foldr patt_imp (C [p]) l)
Γ Ⱶ
"0" ∶ a ---> foldr patt_imp (C [p]) l,
"1" ∶ a,
--------------------------------------
a
using gpi
 mlExactn 1. }
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
a: Pattern
l: list Pattern
wfp: well_formed p
wfq: well_formed q
wfC: PC_wf C
gpi: ProofInfo
pile: ProofInfoLe
  (ExGen := list_to_set
              (evar_fresh_seq
                 (free_evars (pcPattern C)
                  ∪ free_evars p ∪ 
                  free_evars q ∪ {[
                  pcEvar C]})
                 (maximal_exists_depth_to 0
                    (pcEvar C) 
                    (pcPattern C))),
   SVSubst := list_to_set
                (svar_fresh_seq
                   (free_svars (pcPattern C)
                    ∪ free_svars p
                    ∪ free_svars q)
                   (maximal_mu_depth_to 0
                      (pcEvar C) 
                      (pcPattern C))),
   KT := mu_in_evar_path 
           (pcEvar C) (pcPattern C) 0) gpi
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
Himp: Γ ⊢i p <---> q using gpi
IHl: Γ
⊢i foldr patt_imp (C [p]) l <--->
   foldr patt_imp (C [q]) l using gpi
wfal: wf (a :: l)
Hwf1: well_formed
  (foldr patt_imp (C [p]) l <--->
   foldr patt_imp (C [q]) l)
Hwf2: well_formed (p <---> q)
H: well_formed (C [p])
H0: well_formed (C [q])
Hwf: well_formed (foldr patt_imp (C [p]) l)
Γ Ⱶ
"0" ∶ a ---> foldr patt_imp (C [p]) l,
"1" ∶ a,
"2" ∶ foldr patt_imp (C [p]) l,
--------------------------------------
foldr patt_imp (C [q]) l
using gpi

      apply pf_iff_proj1 in IHl.
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
a: Pattern
l: list Pattern
wfp: well_formed p
wfq: well_formed q
wfC: PC_wf C
gpi: ProofInfo
pile: ProofInfoLe
  (ExGen := list_to_set
              (evar_fresh_seq
                 (free_evars (pcPattern C)
                  ∪ free_evars p ∪ 
                  free_evars q ∪ {[
                  pcEvar C]})
                 (maximal_exists_depth_to 0
                    (pcEvar C) 
                    (pcPattern C))),
   SVSubst := list_to_set
                (svar_fresh_seq
                   (free_svars (pcPattern C)
                    ∪ free_svars p
                    ∪ free_svars q)
                   (maximal_mu_depth_to 0
                      (pcEvar C) 
                      (pcPattern C))),
   KT := mu_in_evar_path 
           (pcEvar C) (pcPattern C) 0) gpi
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
Himp: Γ ⊢i p <---> q using gpi
IHl: Γ
⊢i foldr patt_imp (C [p]) l --->
   foldr patt_imp (C [q]) l using gpi
wfal: wf (a :: l)
Hwf1: well_formed
  (foldr patt_imp (C [p]) l <--->
   foldr patt_imp (C [q]) l)
Hwf2: well_formed (p <---> q)
H: well_formed (C [p])
H0: well_formed (C [q])
Hwf: well_formed (foldr patt_imp (C [p]) l)
Γ Ⱶ
"0" ∶ a ---> foldr patt_imp (C [p]) l,
"1" ∶ a,
"2" ∶ foldr patt_imp (C [p]) l,
--------------------------------------
foldr patt_imp (C [q]) l
using gpi
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
a: Pattern
l: list Pattern
wfp: well_formed p
wfq: well_formed q
wfC: PC_wf C
gpi: ProofInfo
pile: ProofInfoLe
  (ExGen := list_to_set
              (evar_fresh_seq
                 (free_evars (pcPattern C)
                  ∪ free_evars p ∪ 
                  free_evars q ∪ {[
                  pcEvar C]})
                 (maximal_exists_depth_to 0
                    (pcEvar C) 
                    (pcPattern C))),
   SVSubst := list_to_set
                (svar_fresh_seq
                   (free_svars (pcPattern C)
                    ∪ free_svars p
                    ∪ free_svars q)
                   (maximal_mu_depth_to 0
                      (pcEvar C) 
                      (pcPattern C))),
   KT := mu_in_evar_path 
           (pcEvar C) (pcPattern C) 0) gpi
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
Himp: Γ ⊢i p <---> q using gpi
IHl: Γ
⊢i foldr patt_imp (C [p]) l <--->
   foldr patt_imp (C [q]) l using gpi
wfal: wf (a :: l)
Hwf1: well_formed
  (foldr patt_imp (C [p]) l <--->
   foldr patt_imp (C [q]) l)
Hwf2: well_formed (p <---> q)
H: well_formed (C [p])
H0: well_formed (C [q])
Hwf: well_formed (foldr patt_imp (C [p]) l)
well_formed (foldr patt_imp (C [p]) l)
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
a: Pattern
l: list Pattern
wfp: well_formed p
wfq: well_formed q
wfC: PC_wf C
gpi: ProofInfo
pile: ProofInfoLe
  (ExGen := list_to_set
              (evar_fresh_seq
                 (free_evars (pcPattern C)
                  ∪ free_evars p ∪ 
                  free_evars q ∪ {[
                  pcEvar C]})
                 (maximal_exists_depth_to 0
                    (pcEvar C) 
                    (pcPattern C))),
   SVSubst := list_to_set
                (svar_fresh_seq
                   (free_svars (pcPattern C)
                    ∪ free_svars p
                    ∪ free_svars q)
                   (maximal_mu_depth_to 0
                      (pcEvar C) 
                      (pcPattern C))),
   KT := mu_in_evar_path 
           (pcEvar C) (pcPattern C) 0) gpi
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
Himp: Γ ⊢i p <---> q using gpi
IHl: Γ
⊢i foldr patt_imp (C [p]) l <--->
   foldr patt_imp (C [q]) l using gpi
wfal: wf (a :: l)
Hwf1: well_formed
  (foldr patt_imp (C [p]) l <--->
   foldr patt_imp (C [q]) l)
Hwf2: well_formed (p <---> q)
H: well_formed (C [p])
H0: well_formed (C [q])
Hwf: well_formed (foldr patt_imp (C [p]) l)
well_formed (foldr patt_imp (C [q]) l)
      2,3: wf_auto2.
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
a: Pattern
l: list Pattern
wfp: well_formed p
wfq: well_formed q
wfC: PC_wf C
gpi: ProofInfo
pile: ProofInfoLe
  (ExGen := list_to_set
              (evar_fresh_seq
                 (free_evars (pcPattern C)
                  ∪ free_evars p ∪ 
                  free_evars q ∪ {[
                  pcEvar C]})
                 (maximal_exists_depth_to 0
                    (pcEvar C) 
                    (pcPattern C))),
   SVSubst := list_to_set
                (svar_fresh_seq
                   (free_svars (pcPattern C)
                    ∪ free_svars p
                    ∪ free_svars q)
                   (maximal_mu_depth_to 0
                      (pcEvar C) 
                      (pcPattern C))),
   KT := mu_in_evar_path 
           (pcEvar C) (pcPattern C) 0) gpi
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
Himp: Γ ⊢i p <---> q using gpi
IHl: Γ
⊢i foldr patt_imp (C [p]) l --->
   foldr patt_imp (C [q]) l using gpi
wfal: wf (a :: l)
Hwf1: well_formed
  (foldr patt_imp (C [p]) l <--->
   foldr patt_imp (C [q]) l)
Hwf2: well_formed (p <---> q)
H: well_formed (C [p])
H0: well_formed (C [q])
Hwf: well_formed (foldr patt_imp (C [p]) l)
Γ Ⱶ
"0" ∶ a ---> foldr patt_imp (C [p]) l,
"1" ∶ a,
"2" ∶ foldr patt_imp (C [p]) l,
--------------------------------------
foldr patt_imp (C [q]) l
using gpi

      mlApplyMetaRaw IHl.
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
a: Pattern
l: list Pattern
wfp: well_formed p
wfq: well_formed q
wfC: PC_wf C
gpi: ProofInfo
pile: ProofInfoLe
  (ExGen := list_to_set
              (evar_fresh_seq
                 (free_evars (pcPattern C)
                  ∪ free_evars p ∪ 
                  free_evars q ∪ {[
                  pcEvar C]})
                 (maximal_exists_depth_to 0
                    (pcEvar C) 
                    (pcPattern C))),
   SVSubst := list_to_set
                (svar_fresh_seq
                   (free_svars (pcPattern C)
                    ∪ free_svars p
                    ∪ free_svars q)
                   (maximal_mu_depth_to 0
                      (pcEvar C) 
                      (pcPattern C))),
   KT := mu_in_evar_path 
           (pcEvar C) (pcPattern C) 0) gpi
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
Himp: Γ ⊢i p <---> q using gpi
IHl: Γ
⊢i foldr patt_imp (C [p]) l --->
   foldr patt_imp (C [q]) l using gpi
wfal: wf (a :: l)
Hwf1: well_formed
  (foldr patt_imp (C [p]) l <--->
   foldr patt_imp (C [q]) l)
Hwf2: well_formed (p <---> q)
H: well_formed (C [p])
H0: well_formed (C [q])
Hwf: well_formed (foldr patt_imp (C [p]) l)
Γ Ⱶ
"0" ∶ a ---> foldr patt_imp (C [p]) l,
"1" ∶ a,
"2" ∶ foldr patt_imp (C [p]) l,
--------------------------------------
foldr patt_imp (C [p]) l
using gpi

      mlExactn 2.
    +
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
a: Pattern
l: list Pattern
wfp: well_formed p
wfq: well_formed q
wfC: PC_wf C
gpi: ProofInfo
pile: ProofInfoLe
  (ExGen := list_to_set
              (evar_fresh_seq
                 (free_evars (pcPattern C)
                  ∪ free_evars p ∪ 
                  free_evars q ∪ {[
                  pcEvar C]})
                 (maximal_exists_depth_to 0
                    (pcEvar C) 
                    (pcPattern C))),
   SVSubst := list_to_set
                (svar_fresh_seq
                   (free_svars (pcPattern C)
                    ∪ free_svars p
                    ∪ free_svars q)
                   (maximal_mu_depth_to 0
                      (pcEvar C) 
                      (pcPattern C))),
   KT := mu_in_evar_path 
           (pcEvar C) (pcPattern C) 0) gpi
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
Himp: Γ ⊢i p <---> q using gpi
IHl: Γ
⊢i foldr patt_imp (C [p]) l <--->
   foldr patt_imp (C [q]) l using gpi
wfal: wf (a :: l)
Hwf1: well_formed
  (foldr patt_imp (C [p]) l <--->
   foldr patt_imp (C [q]) l)
Hwf2: well_formed (p <---> q)
H: well_formed (C [p])
H0: well_formed (C [q])
Γ Ⱶ
(a ---> foldr patt_imp (C [q]) l) --->
a ---> foldr patt_imp (C [p]) l
using gpi
 mlIntro.
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
a: Pattern
l: list Pattern
wfp: well_formed p
wfq: well_formed q
wfC: PC_wf C
gpi: ProofInfo
pile: ProofInfoLe
  (ExGen := list_to_set
              (evar_fresh_seq
                 (free_evars (pcPattern C)
                  ∪ free_evars p ∪ 
                  free_evars q ∪ {[
                  pcEvar C]})
                 (maximal_exists_depth_to 0
                    (pcEvar C) 
                    (pcPattern C))),
   SVSubst := list_to_set
                (svar_fresh_seq
                   (free_svars (pcPattern C)
                    ∪ free_svars p
                    ∪ free_svars q)
                   (maximal_mu_depth_to 0
                      (pcEvar C) 
                      (pcPattern C))),
   KT := mu_in_evar_path 
           (pcEvar C) (pcPattern C) 0) gpi
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
Himp: Γ ⊢i p <---> q using gpi
IHl: Γ
⊢i foldr patt_imp (C [p]) l <--->
   foldr patt_imp (C [q]) l using gpi
wfal: wf (a :: l)
Hwf1: well_formed
  (foldr patt_imp (C [p]) l <--->
   foldr patt_imp (C [q]) l)
Hwf2: well_formed (p <---> q)
H: well_formed (C [p])
H0: well_formed (C [q])
Γ Ⱶ
"0" ∶ a ---> foldr patt_imp (C [q]) l,
--------------------------------------
a ---> foldr patt_imp (C [p]) l
using gpi
 mlIntro.
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
a: Pattern
l: list Pattern
wfp: well_formed p
wfq: well_formed q
wfC: PC_wf C
gpi: ProofInfo
pile: ProofInfoLe
  (ExGen := list_to_set
              (evar_fresh_seq
                 (free_evars (pcPattern C)
                  ∪ free_evars p ∪ 
                  free_evars q ∪ {[
                  pcEvar C]})
                 (maximal_exists_depth_to 0
                    (pcEvar C) 
                    (pcPattern C))),
   SVSubst := list_to_set
                (svar_fresh_seq
                   (free_svars (pcPattern C)
                    ∪ free_svars p
                    ∪ free_svars q)
                   (maximal_mu_depth_to 0
                      (pcEvar C) 
                      (pcPattern C))),
   KT := mu_in_evar_path 
           (pcEvar C) (pcPattern C) 0) gpi
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
Himp: Γ ⊢i p <---> q using gpi
IHl: Γ
⊢i foldr patt_imp (C [p]) l <--->
   foldr patt_imp (C [q]) l using gpi
wfal: wf (a :: l)
Hwf1: well_formed
  (foldr patt_imp (C [p]) l <--->
   foldr patt_imp (C [q]) l)
Hwf2: well_formed (p <---> q)
H: well_formed (C [p])
H0: well_formed (C [q])
Γ Ⱶ
"0" ∶ a ---> foldr patt_imp (C [q]) l,
"1" ∶ a,
--------------------------------------
foldr patt_imp (C [p]) l
using gpi

      mlAssert ((foldr patt_imp (emplace C q) l)).
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
a: Pattern
l: list Pattern
wfp: well_formed p
wfq: well_formed q
wfC: PC_wf C
gpi: ProofInfo
pile: ProofInfoLe
  (ExGen := list_to_set
              (evar_fresh_seq
                 (free_evars (pcPattern C)
                  ∪ free_evars p ∪ 
                  free_evars q ∪ {[
                  pcEvar C]})
                 (maximal_exists_depth_to 0
                    (pcEvar C) 
                    (pcPattern C))),
   SVSubst := list_to_set
                (svar_fresh_seq
                   (free_svars (pcPattern C)
                    ∪ free_svars p
                    ∪ free_svars q)
                   (maximal_mu_depth_to 0
                      (pcEvar C) 
                      (pcPattern C))),
   KT := mu_in_evar_path 
           (pcEvar C) (pcPattern C) 0) gpi
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
Himp: Γ ⊢i p <---> q using gpi
IHl: Γ
⊢i foldr patt_imp (C [p]) l <--->
   foldr patt_imp (C [q]) l using gpi
wfal: wf (a :: l)
Hwf1: well_formed
  (foldr patt_imp (C [p]) l <--->
   foldr patt_imp (C [q]) l)
Hwf2: well_formed (p <---> q)
H: well_formed (C [p])
H0: well_formed (C [q])
well_formed (foldr patt_imp (C [q]) l)
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
a: Pattern
l: list Pattern
wfp: well_formed p
wfq: well_formed q
wfC: PC_wf C
gpi: ProofInfo
pile: ProofInfoLe
  (ExGen := list_to_set
              (evar_fresh_seq
                 (free_evars (pcPattern C)
                  ∪ free_evars p ∪ 
                  free_evars q ∪ {[
                  pcEvar C]})
                 (maximal_exists_depth_to 0
                    (pcEvar C) 
                    (pcPattern C))),
   SVSubst := list_to_set
                (svar_fresh_seq
                   (free_svars (pcPattern C)
                    ∪ free_svars p
                    ∪ free_svars q)
                   (maximal_mu_depth_to 0
                      (pcEvar C) 
                      (pcPattern C))),
   KT := mu_in_evar_path 
           (pcEvar C) (pcPattern C) 0) gpi
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
Himp: Γ ⊢i p <---> q using gpi
IHl: Γ
⊢i foldr patt_imp (C [p]) l <--->
   foldr patt_imp (C [q]) l using gpi
wfal: wf (a :: l)
Hwf1: well_formed
  (foldr patt_imp (C [p]) l <--->
   foldr patt_imp (C [q]) l)
Hwf2: well_formed (p <---> q)
H: well_formed (C [p])
H0: well_formed (C [q])
Hwf: well_formed (foldr patt_imp (C [q]) l)
Γ Ⱶ
"0" ∶ a ---> foldr patt_imp (C [q]) l,
"1" ∶ a,
--------------------------------------
foldr patt_imp (C [q]) l
using gpi
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
a: Pattern
l: list Pattern
wfp: well_formed p
wfq: well_formed q
wfC: PC_wf C
gpi: ProofInfo
pile: ProofInfoLe
  (ExGen := list_to_set
              (evar_fresh_seq
                 (free_evars (pcPattern C)
                  ∪ free_evars p ∪ 
                  free_evars q ∪ {[
                  pcEvar C]})
                 (maximal_exists_depth_to 0
                    (pcEvar C) 
                    (pcPattern C))),
   SVSubst := list_to_set
                (svar_fresh_seq
                   (free_svars (pcPattern C)
                    ∪ free_svars p
                    ∪ free_svars q)
                   (maximal_mu_depth_to 0
                      (pcEvar C) 
                      (pcPattern C))),
   KT := mu_in_evar_path 
           (pcEvar C) (pcPattern C) 0) gpi
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
Himp: Γ ⊢i p <---> q using gpi
IHl: Γ
⊢i foldr patt_imp (C [p]) l <--->
   foldr patt_imp (C [q]) l using gpi
wfal: wf (a :: l)
Hwf1: well_formed
  (foldr patt_imp (C [p]) l <--->
   foldr patt_imp (C [q]) l)
Hwf2: well_formed (p <---> q)
H: well_formed (C [p])
H0: well_formed (C [q])
Hwf: well_formed (foldr patt_imp (C [q]) l)
Γ Ⱶ
"0" ∶ a ---> foldr patt_imp (C [q]) l,
"1" ∶ a,
"2" ∶ foldr patt_imp (C [q]) l,
--------------------------------------
foldr patt_imp (C [p]) l
using gpi

      {
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
a: Pattern
l: list Pattern
wfp: well_formed p
wfq: well_formed q
wfC: PC_wf C
gpi: ProofInfo
pile: ProofInfoLe
  (ExGen := list_to_set
              (evar_fresh_seq
                 (free_evars (pcPattern C)
                  ∪ free_evars p ∪ 
                  free_evars q ∪ {[
                  pcEvar C]})
                 (maximal_exists_depth_to 0
                    (pcEvar C) 
                    (pcPattern C))),
   SVSubst := list_to_set
                (svar_fresh_seq
                   (free_svars (pcPattern C)
                    ∪ free_svars p
                    ∪ free_svars q)
                   (maximal_mu_depth_to 0
                      (pcEvar C) 
                      (pcPattern C))),
   KT := mu_in_evar_path 
           (pcEvar C) (pcPattern C) 0) gpi
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
Himp: Γ ⊢i p <---> q using gpi
IHl: Γ
⊢i foldr patt_imp (C [p]) l <--->
   foldr patt_imp (C [q]) l using gpi
wfal: wf (a :: l)
Hwf1: well_formed
  (foldr patt_imp (C [p]) l <--->
   foldr patt_imp (C [q]) l)
Hwf2: well_formed (p <---> q)
H: well_formed (C [p])
H0: well_formed (C [q])
well_formed (foldr patt_imp (C [q]) l) wf_auto2. }
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
a: Pattern
l: list Pattern
wfp: well_formed p
wfq: well_formed q
wfC: PC_wf C
gpi: ProofInfo
pile: ProofInfoLe
  (ExGen := list_to_set
              (evar_fresh_seq
                 (free_evars (pcPattern C)
                  ∪ free_evars p ∪ 
                  free_evars q ∪ {[
                  pcEvar C]})
                 (maximal_exists_depth_to 0
                    (pcEvar C) 
                    (pcPattern C))),
   SVSubst := list_to_set
                (svar_fresh_seq
                   (free_svars (pcPattern C)
                    ∪ free_svars p
                    ∪ free_svars q)
                   (maximal_mu_depth_to 0
                      (pcEvar C) 
                      (pcPattern C))),
   KT := mu_in_evar_path 
           (pcEvar C) (pcPattern C) 0) gpi
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
Himp: Γ ⊢i p <---> q using gpi
IHl: Γ
⊢i foldr patt_imp (C [p]) l <--->
   foldr patt_imp (C [q]) l using gpi
wfal: wf (a :: l)
Hwf1: well_formed
  (foldr patt_imp (C [p]) l <--->
   foldr patt_imp (C [q]) l)
Hwf2: well_formed (p <---> q)
H: well_formed (C [p])
H0: well_formed (C [q])
Hwf: well_formed (foldr patt_imp (C [q]) l)
Γ Ⱶ
"0" ∶ a ---> foldr patt_imp (C [q]) l,
"1" ∶ a,
--------------------------------------
foldr patt_imp (C [q]) l
using gpi
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
a: Pattern
l: list Pattern
wfp: well_formed p
wfq: well_formed q
wfC: PC_wf C
gpi: ProofInfo
pile: ProofInfoLe
  (ExGen := list_to_set
              (evar_fresh_seq
                 (free_evars (pcPattern C)
                  ∪ free_evars p ∪ 
                  free_evars q ∪ {[
                  pcEvar C]})
                 (maximal_exists_depth_to 0
                    (pcEvar C) 
                    (pcPattern C))),
   SVSubst := list_to_set
                (svar_fresh_seq
                   (free_svars (pcPattern C)
                    ∪ free_svars p
                    ∪ free_svars q)
                   (maximal_mu_depth_to 0
                      (pcEvar C) 
                      (pcPattern C))),
   KT := mu_in_evar_path 
           (pcEvar C) (pcPattern C) 0) gpi
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
Himp: Γ ⊢i p <---> q using gpi
IHl: Γ
⊢i foldr patt_imp (C [p]) l <--->
   foldr patt_imp (C [q]) l using gpi
wfal: wf (a :: l)
Hwf1: well_formed
  (foldr patt_imp (C [p]) l <--->
   foldr patt_imp (C [q]) l)
Hwf2: well_formed (p <---> q)
H: well_formed (C [p])
H0: well_formed (C [q])
Hwf: well_formed (foldr patt_imp (C [q]) l)
Γ Ⱶ
"0" ∶ a ---> foldr patt_imp (C [q]) l,
"1" ∶ a,
"2" ∶ foldr patt_imp (C [q]) l,
--------------------------------------
foldr patt_imp (C [p]) l
using gpi

      {
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
a: Pattern
l: list Pattern
wfp: well_formed p
wfq: well_formed q
wfC: PC_wf C
gpi: ProofInfo
pile: ProofInfoLe
  (ExGen := list_to_set
              (evar_fresh_seq
                 (free_evars (pcPattern C)
                  ∪ free_evars p ∪ 
                  free_evars q ∪ {[
                  pcEvar C]})
                 (maximal_exists_depth_to 0
                    (pcEvar C) 
                    (pcPattern C))),
   SVSubst := list_to_set
                (svar_fresh_seq
                   (free_svars (pcPattern C)
                    ∪ free_svars p
                    ∪ free_svars q)
                   (maximal_mu_depth_to 0
                      (pcEvar C) 
                      (pcPattern C))),
   KT := mu_in_evar_path 
           (pcEvar C) (pcPattern C) 0) gpi
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
Himp: Γ ⊢i p <---> q using gpi
IHl: Γ
⊢i foldr patt_imp (C [p]) l <--->
   foldr patt_imp (C [q]) l using gpi
wfal: wf (a :: l)
Hwf1: well_formed
  (foldr patt_imp (C [p]) l <--->
   foldr patt_imp (C [q]) l)
Hwf2: well_formed (p <---> q)
H: well_formed (C [p])
H0: well_formed (C [q])
Hwf: well_formed (foldr patt_imp (C [q]) l)
Γ Ⱶ
"0" ∶ a ---> foldr patt_imp (C [q]) l,
"1" ∶ a,
--------------------------------------
foldr patt_imp (C [q]) l
using gpi
 mlApply "0".
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
a: Pattern
l: list Pattern
wfp: well_formed p
wfq: well_formed q
wfC: PC_wf C
gpi: ProofInfo
pile: ProofInfoLe
  (ExGen := list_to_set
              (evar_fresh_seq
                 (free_evars (pcPattern C)
                  ∪ free_evars p ∪ 
                  free_evars q ∪ {[
                  pcEvar C]})
                 (maximal_exists_depth_to 0
                    (pcEvar C) 
                    (pcPattern C))),
   SVSubst := list_to_set
                (svar_fresh_seq
                   (free_svars (pcPattern C)
                    ∪ free_svars p
                    ∪ free_svars q)
                   (maximal_mu_depth_to 0
                      (pcEvar C) 
                      (pcPattern C))),
   KT := mu_in_evar_path 
           (pcEvar C) (pcPattern C) 0) gpi
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
Himp: Γ ⊢i p <---> q using gpi
IHl: Γ
⊢i foldr patt_imp (C [p]) l <--->
   foldr patt_imp (C [q]) l using gpi
wfal: wf (a :: l)
Hwf1: well_formed
  (foldr patt_imp (C [p]) l <--->
   foldr patt_imp (C [q]) l)
Hwf2: well_formed (p <---> q)
H: well_formed (C [p])
H0: well_formed (C [q])
Hwf: well_formed (foldr patt_imp (C [q]) l)
Γ Ⱶ
"0" ∶ a ---> foldr patt_imp (C [q]) l,
"1" ∶ a,
--------------------------------------
a
using gpi
 mlExactn 1. }
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
a: Pattern
l: list Pattern
wfp: well_formed p
wfq: well_formed q
wfC: PC_wf C
gpi: ProofInfo
pile: ProofInfoLe
  (ExGen := list_to_set
              (evar_fresh_seq
                 (free_evars (pcPattern C)
                  ∪ free_evars p ∪ 
                  free_evars q ∪ {[
                  pcEvar C]})
                 (maximal_exists_depth_to 0
                    (pcEvar C) 
                    (pcPattern C))),
   SVSubst := list_to_set
                (svar_fresh_seq
                   (free_svars (pcPattern C)
                    ∪ free_svars p
                    ∪ free_svars q)
                   (maximal_mu_depth_to 0
                      (pcEvar C) 
                      (pcPattern C))),
   KT := mu_in_evar_path 
           (pcEvar C) (pcPattern C) 0) gpi
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
Himp: Γ ⊢i p <---> q using gpi
IHl: Γ
⊢i foldr patt_imp (C [p]) l <--->
   foldr patt_imp (C [q]) l using gpi
wfal: wf (a :: l)
Hwf1: well_formed
  (foldr patt_imp (C [p]) l <--->
   foldr patt_imp (C [q]) l)
Hwf2: well_formed (p <---> q)
H: well_formed (C [p])
H0: well_formed (C [q])
Hwf: well_formed (foldr patt_imp (C [q]) l)
Γ Ⱶ
"0" ∶ a ---> foldr patt_imp (C [q]) l,
"1" ∶ a,
"2" ∶ foldr patt_imp (C [q]) l,
--------------------------------------
foldr patt_imp (C [p]) l
using gpi

      apply pf_iff_proj2 in IHl.
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
a: Pattern
l: list Pattern
wfp: well_formed p
wfq: well_formed q
wfC: PC_wf C
gpi: ProofInfo
pile: ProofInfoLe
  (ExGen := list_to_set
              (evar_fresh_seq
                 (free_evars (pcPattern C)
                  ∪ free_evars p ∪ 
                  free_evars q ∪ {[
                  pcEvar C]})
                 (maximal_exists_depth_to 0
                    (pcEvar C) 
                    (pcPattern C))),
   SVSubst := list_to_set
                (svar_fresh_seq
                   (free_svars (pcPattern C)
                    ∪ free_svars p
                    ∪ free_svars q)
                   (maximal_mu_depth_to 0
                      (pcEvar C) 
                      (pcPattern C))),
   KT := mu_in_evar_path 
           (pcEvar C) (pcPattern C) 0) gpi
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
Himp: Γ ⊢i p <---> q using gpi
IHl: Γ
⊢i foldr patt_imp (C [q]) l --->
   foldr patt_imp (C [p]) l using gpi
wfal: wf (a :: l)
Hwf1: well_formed
  (foldr patt_imp (C [p]) l <--->
   foldr patt_imp (C [q]) l)
Hwf2: well_formed (p <---> q)
H: well_formed (C [p])
H0: well_formed (C [q])
Hwf: well_formed (foldr patt_imp (C [q]) l)
Γ Ⱶ
"0" ∶ a ---> foldr patt_imp (C [q]) l,
"1" ∶ a,
"2" ∶ foldr patt_imp (C [q]) l,
--------------------------------------
foldr patt_imp (C [p]) l
using gpi
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
a: Pattern
l: list Pattern
wfp: well_formed p
wfq: well_formed q
wfC: PC_wf C
gpi: ProofInfo
pile: ProofInfoLe
  (ExGen := list_to_set
              (evar_fresh_seq
                 (free_evars (pcPattern C)
                  ∪ free_evars p ∪ 
                  free_evars q ∪ {[
                  pcEvar C]})
                 (maximal_exists_depth_to 0
                    (pcEvar C) 
                    (pcPattern C))),
   SVSubst := list_to_set
                (svar_fresh_seq
                   (free_svars (pcPattern C)
                    ∪ free_svars p
                    ∪ free_svars q)
                   (maximal_mu_depth_to 0
                      (pcEvar C) 
                      (pcPattern C))),
   KT := mu_in_evar_path 
           (pcEvar C) (pcPattern C) 0) gpi
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
Himp: Γ ⊢i p <---> q using gpi
IHl: Γ
⊢i foldr patt_imp (C [p]) l <--->
   foldr patt_imp (C [q]) l using gpi
wfal: wf (a :: l)
Hwf1: well_formed
  (foldr patt_imp (C [p]) l <--->
   foldr patt_imp (C [q]) l)
Hwf2: well_formed (p <---> q)
H: well_formed (C [p])
H0: well_formed (C [q])
Hwf: well_formed (foldr patt_imp (C [q]) l)
well_formed (foldr patt_imp (C [p]) l)
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
a: Pattern
l: list Pattern
wfp: well_formed p
wfq: well_formed q
wfC: PC_wf C
gpi: ProofInfo
pile: ProofInfoLe
  (ExGen := list_to_set
              (evar_fresh_seq
                 (free_evars (pcPattern C)
                  ∪ free_evars p ∪ 
                  free_evars q ∪ {[
                  pcEvar C]})
                 (maximal_exists_depth_to 0
                    (pcEvar C) 
                    (pcPattern C))),
   SVSubst := list_to_set
                (svar_fresh_seq
                   (free_svars (pcPattern C)
                    ∪ free_svars p
                    ∪ free_svars q)
                   (maximal_mu_depth_to 0
                      (pcEvar C) 
                      (pcPattern C))),
   KT := mu_in_evar_path 
           (pcEvar C) (pcPattern C) 0) gpi
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
Himp: Γ ⊢i p <---> q using gpi
IHl: Γ
⊢i foldr patt_imp (C [p]) l <--->
   foldr patt_imp (C [q]) l using gpi
wfal: wf (a :: l)
Hwf1: well_formed
  (foldr patt_imp (C [p]) l <--->
   foldr patt_imp (C [q]) l)
Hwf2: well_formed (p <---> q)
H: well_formed (C [p])
H0: well_formed (C [q])
Hwf: well_formed (foldr patt_imp (C [q]) l)
well_formed (foldr patt_imp (C [q]) l)
      2,3: wf_auto2.
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
a: Pattern
l: list Pattern
wfp: well_formed p
wfq: well_formed q
wfC: PC_wf C
gpi: ProofInfo
pile: ProofInfoLe
  (ExGen := list_to_set
              (evar_fresh_seq
                 (free_evars (pcPattern C)
                  ∪ free_evars p ∪ 
                  free_evars q ∪ {[
                  pcEvar C]})
                 (maximal_exists_depth_to 0
                    (pcEvar C) 
                    (pcPattern C))),
   SVSubst := list_to_set
                (svar_fresh_seq
                   (free_svars (pcPattern C)
                    ∪ free_svars p
                    ∪ free_svars q)
                   (maximal_mu_depth_to 0
                      (pcEvar C) 
                      (pcPattern C))),
   KT := mu_in_evar_path 
           (pcEvar C) (pcPattern C) 0) gpi
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
Himp: Γ ⊢i p <---> q using gpi
IHl: Γ
⊢i foldr patt_imp (C [q]) l --->
   foldr patt_imp (C [p]) l using gpi
wfal: wf (a :: l)
Hwf1: well_formed
  (foldr patt_imp (C [p]) l <--->
   foldr patt_imp (C [q]) l)
Hwf2: well_formed (p <---> q)
H: well_formed (C [p])
H0: well_formed (C [q])
Hwf: well_formed (foldr patt_imp (C [q]) l)
Γ Ⱶ
"0" ∶ a ---> foldr patt_imp (C [q]) l,
"1" ∶ a,
"2" ∶ foldr patt_imp (C [q]) l,
--------------------------------------
foldr patt_imp (C [p]) l
using gpi

      mlApplyMetaRaw IHl.
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
a: Pattern
l: list Pattern
wfp: well_formed p
wfq: well_formed q
wfC: PC_wf C
gpi: ProofInfo
pile: ProofInfoLe
  (ExGen := list_to_set
              (evar_fresh_seq
                 (free_evars (pcPattern C)
                  ∪ free_evars p ∪ 
                  free_evars q ∪ {[
                  pcEvar C]})
                 (maximal_exists_depth_to 0
                    (pcEvar C) 
                    (pcPattern C))),
   SVSubst := list_to_set
                (svar_fresh_seq
                   (free_svars (pcPattern C)
                    ∪ free_svars p
                    ∪ free_svars q)
                   (maximal_mu_depth_to 0
                      (pcEvar C) 
                      (pcPattern C))),
   KT := mu_in_evar_path 
           (pcEvar C) (pcPattern C) 0) gpi
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
Himp: Γ ⊢i p <---> q using gpi
IHl: Γ
⊢i foldr patt_imp (C [q]) l --->
   foldr patt_imp (C [p]) l using gpi
wfal: wf (a :: l)
Hwf1: well_formed
  (foldr patt_imp (C [p]) l <--->
   foldr patt_imp (C [q]) l)
Hwf2: well_formed (p <---> q)
H: well_formed (C [p])
H0: well_formed (C [q])
Hwf: well_formed (foldr patt_imp (C [q]) l)
Γ Ⱶ
"0" ∶ a ---> foldr patt_imp (C [q]) l,
"1" ∶ a,
"2" ∶ foldr patt_imp (C [q]) l,
--------------------------------------
foldr patt_imp (C [q]) l
using gpi

      mlExactn 2.
Defined.

Lemma extract_wfp {Σ : Signature} (Γ : Theory) (p q : Pattern) (i : ProofInfo):
  Γ ⊢i p <---> q using i ->
  well_formed p.
Σ: Signature
Γ: Theory
p, q: Pattern
i: ProofInfo
Γ ⊢i p <---> q using i → well_formed p
Proof.
Σ: Signature
Γ: Theory
p, q: Pattern
i: ProofInfo
Γ ⊢i p <---> q using i → well_formed p
  intros H.
Σ: Signature
Γ: Theory
p, q: Pattern
i: ProofInfo
H: Γ ⊢i p <---> q using i
well_formed p
  pose proof (H' := proj1_sig H).
Σ: Signature
Γ: Theory
p, q: Pattern
i: ProofInfo
H: Γ ⊢i p <---> q using i
H': ML_proof_system Γ (p <---> q)
well_formed p
  apply proved_impl_wf in H'.
Σ: Signature
Γ: Theory
p, q: Pattern
i: ProofInfo
H: Γ ⊢i p <---> q using i
H': well_formed (p <---> q)
well_formed p
  wf_auto2.
Qed.

Lemma extract_wfq {Σ : Signature} (Γ : Theory) (p q : Pattern) (i : ProofInfo):
  Γ ⊢i p <---> q using i ->
  well_formed q.
Σ: Signature
Γ: Theory
p, q: Pattern
i: ProofInfo
Γ ⊢i p <---> q using i → well_formed q
Proof.
Σ: Signature
Γ: Theory
p, q: Pattern
i: ProofInfo
Γ ⊢i p <---> q using i → well_formed q
  intros H.
Σ: Signature
Γ: Theory
p, q: Pattern
i: ProofInfo
H: Γ ⊢i p <---> q using i
well_formed q
  pose proof (H' := proj1_sig H).
Σ: Signature
Γ: Theory
p, q: Pattern
i: ProofInfo
H: Γ ⊢i p <---> q using i
H': ML_proof_system Γ (p <---> q)
well_formed q
  apply proved_impl_wf in H'.
Σ: Signature
Γ: Theory
p, q: Pattern
i: ProofInfo
H: Γ ⊢i p <---> q using i
H': well_formed (p <---> q)
well_formed q
  wf_auto2.
Qed.

Lemma MLGoal_rewriteIff
  {Σ : Signature} (Γ : Theory) (p q : Pattern) (C : PatternCtx) l (gpi : ProofInfo)
  (wfC : PC_wf C)
  (pf : Γ ⊢i p <---> q using ( gpi)) :
  mkMLGoal Σ Γ l (emplace C q) ( gpi) ->
  (ProofInfoLe
    (ExGen := list_to_set (evar_fresh_seq (free_evars (pcPattern C) ∪ free_evars p ∪ free_evars q ∪ {[pcEvar C]}) (maximal_exists_depth_to 0 (pcEvar C) (pcPattern C))),
     SVSubst := list_to_set (svar_fresh_seq (free_svars (pcPattern C) ∪
                free_svars p ∪ free_svars q) (maximal_mu_depth_to 0 (pcEvar C) (pcPattern C))),
     KT := mu_in_evar_path (pcEvar C) (pcPattern C) 0
  )
      gpi) ->
  mkMLGoal Σ Γ l (emplace C p) ( gpi).
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
l: hypotheses
gpi: ProofInfo
wfC: PC_wf C
pf: Γ ⊢i p <---> q using gpi
Γ Ⱶ
l--------------------------------------
C [q]
using gpi

→ ProofInfoLe
    (ExGen := list_to_set
                (evar_fresh_seq
                   (free_evars (pcPattern C)
                    ∪ free_evars p ∪ free_evars q
                    ∪ {[pcEvar C]})
                   (maximal_exists_depth_to 0
                      (pcEvar C) (pcPattern C))),
     SVSubst := list_to_set
                  (svar_fresh_seq
                     (free_svars (pcPattern C)
                      ∪ free_svars p ∪ free_svars q)
                     (maximal_mu_depth_to 0 (pcEvar C)
                        (pcPattern C))),
     KT := mu_in_evar_path (pcEvar C) (pcPattern C) 0)
    gpi
  → Γ Ⱶ
  l--------------------------------------
  C [p]
  using gpi
  
Proof.
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
l: hypotheses
gpi: ProofInfo
wfC: PC_wf C
pf: Γ ⊢i p <---> q using gpi
Γ Ⱶ
l--------------------------------------
C [q]
using gpi

→ ProofInfoLe
    (ExGen := list_to_set
                (evar_fresh_seq
                   (free_evars (pcPattern C)
                    ∪ free_evars p ∪ free_evars q
                    ∪ {[pcEvar C]})
                   (maximal_exists_depth_to 0
                      (pcEvar C) (pcPattern C))),
     SVSubst := list_to_set
                  (svar_fresh_seq
                     (free_svars (pcPattern C)
                      ∪ free_svars p ∪ free_svars q)
                     (maximal_mu_depth_to 0 (pcEvar C)
                        (pcPattern C))),
     KT := mu_in_evar_path (pcEvar C) (pcPattern C) 0)
    gpi
  → Γ Ⱶ
  l--------------------------------------
  C [p]
  using gpi
  
  rename pf into Hpiffq.
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
l: hypotheses
gpi: ProofInfo
wfC: PC_wf C
Hpiffq: Γ ⊢i p <---> q using gpi
Γ Ⱶ
l--------------------------------------
C [q]
using gpi

→ ProofInfoLe
    (ExGen := list_to_set
                (evar_fresh_seq
                   (free_evars (pcPattern C)
                    ∪ free_evars p ∪ free_evars q
                    ∪ {[pcEvar C]})
                   (maximal_exists_depth_to 0
                      (pcEvar C) (pcPattern C))),
     SVSubst := list_to_set
                  (svar_fresh_seq
                     (free_svars (pcPattern C)
                      ∪ free_svars p ∪ free_svars q)
                     (maximal_mu_depth_to 0 (pcEvar C)
                        (pcPattern C))),
     KT := mu_in_evar_path (pcEvar C) (pcPattern C) 0)
    gpi
  → Γ Ⱶ
  l--------------------------------------
  C [p]
  using gpi
  
  intros H pile.
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
l: hypotheses
gpi: ProofInfo
wfC: PC_wf C
Hpiffq: Γ ⊢i p <---> q using gpi
H: Γ Ⱶ
l--------------------------------------
C [q]
using gpi

pile: ProofInfoLe
  (ExGen := list_to_set
              (evar_fresh_seq
                 (free_evars (pcPattern C)
                  ∪ free_evars p ∪ 
                  free_evars q ∪ {[
                  pcEvar C]})
                 (maximal_exists_depth_to 0
                    (pcEvar C) 
                    (pcPattern C))),
   SVSubst := list_to_set
                (svar_fresh_seq
                   (free_svars (pcPattern C)
                    ∪ free_svars p
                    ∪ free_svars q)
                   (maximal_mu_depth_to 0
                      (pcEvar C) 
                      (pcPattern C))),
   KT := mu_in_evar_path 
           (pcEvar C) (pcPattern C) 0) gpi
Γ Ⱶ
l--------------------------------------
C [p]
using gpi

  unfold of_MLGoal in *.
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
l: hypotheses
gpi: ProofInfo
wfC: PC_wf C
Hpiffq: Γ ⊢i p <---> q using gpi
H: well_formed
  (mlConclusion
     (Γ Ⱶ
      l--------------------------------------
      C [q]
      using gpi
      ))
→ wf
    (patterns_of
       (mlHypotheses
          (Γ Ⱶ
           l--------------------------------------
           C [q]
           using gpi
           )))
  → mlTheory
      (Γ Ⱶ
       l--------------------------------------
       C [q]
       using gpi
       )
    ⊢i foldr patt_imp
         (mlConclusion
            (Γ Ⱶ
             l--------------------------------------
             C [q]
             using gpi
             ))
         (patterns_of
            (mlHypotheses
               (Γ Ⱶ
                l--------------------------------------
                C [q]
                using gpi
                )))
    using mlInfo
            (Γ Ⱶ
             l--------------------------------------
             C [q]
             using gpi
             )
pile: ProofInfoLe
  (ExGen := list_to_set
              (evar_fresh_seq
                 (free_evars (pcPattern C)
                  ∪ free_evars p ∪ 
                  free_evars q ∪ {[
                  pcEvar C]})
                 (maximal_exists_depth_to 0
                    (pcEvar C) 
                    (pcPattern C))),
   SVSubst := list_to_set
                (svar_fresh_seq
                   (free_svars (pcPattern C)
                    ∪ free_svars p
                    ∪ free_svars q)
                   (maximal_mu_depth_to 0
                      (pcEvar C) 
                      (pcPattern C))),
   KT := mu_in_evar_path 
           (pcEvar C) (pcPattern C) 0) gpi
well_formed
  (mlConclusion
     (Γ Ⱶ
      l--------------------------------------
      C [p]
      using gpi
      ))
→ wf
    (patterns_of
       (mlHypotheses
          (Γ Ⱶ
           l--------------------------------------
           C [p]
           using gpi
           )))
  → mlTheory
      (Γ Ⱶ
       l--------------------------------------
       C [p]
       using gpi
       )
    ⊢i foldr patt_imp
         (mlConclusion
            (Γ Ⱶ
             l--------------------------------------
             C [p]
             using gpi
             ))
         (patterns_of
            (mlHypotheses
               (Γ Ⱶ
                l--------------------------------------
                C [p]
                using gpi
                )))
    using mlInfo
            (Γ Ⱶ
             l--------------------------------------
             C [p]
             using gpi
             ) simpl in *.
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
l: hypotheses
gpi: ProofInfo
wfC: PC_wf C
Hpiffq: Γ ⊢i p <---> q using gpi
H: well_formed (C [q])
→ wf (patterns_of l)
  → Γ ⊢i foldr patt_imp (C [q]) (patterns_of l)
    using gpi
pile: ProofInfoLe
  (ExGen := list_to_set
              (evar_fresh_seq
                 (free_evars (pcPattern C)
                  ∪ free_evars p ∪ 
                  free_evars q ∪ {[
                  pcEvar C]})
                 (maximal_exists_depth_to 0
                    (pcEvar C) 
                    (pcPattern C))),
   SVSubst := list_to_set
                (svar_fresh_seq
                   (free_svars (pcPattern C)
                    ∪ free_svars p
                    ∪ free_svars q)
                   (maximal_mu_depth_to 0
                      (pcEvar C) 
                      (pcPattern C))),
   KT := mu_in_evar_path 
           (pcEvar C) (pcPattern C) 0) gpi
well_formed (C [p])
→ wf (patterns_of l)
  → Γ ⊢i foldr patt_imp (C [p]) (patterns_of l)
    using gpi
  intros wfcp wfl.
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
l: hypotheses
gpi: ProofInfo
wfC: PC_wf C
Hpiffq: Γ ⊢i p <---> q using gpi
H: well_formed (C [q])
→ wf (patterns_of l)
  → Γ ⊢i foldr patt_imp (C [q]) (patterns_of l)
    using gpi
pile: ProofInfoLe
  (ExGen := list_to_set
              (evar_fresh_seq
                 (free_evars (pcPattern C)
                  ∪ free_evars p ∪ 
                  free_evars q ∪ {[
                  pcEvar C]})
                 (maximal_exists_depth_to 0
                    (pcEvar C) 
                    (pcPattern C))),
   SVSubst := list_to_set
                (svar_fresh_seq
                   (free_svars (pcPattern C)
                    ∪ free_svars p
                    ∪ free_svars q)
                   (maximal_mu_depth_to 0
                      (pcEvar C) 
                      (pcPattern C))),
   KT := mu_in_evar_path 
           (pcEvar C) (pcPattern C) 0) gpi
wfcp: well_formed (C [p])
wfl: wf (patterns_of l)
Γ ⊢i foldr patt_imp (C [p]) (patterns_of l) using gpi
  feed specialize H.
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
l: hypotheses
gpi: ProofInfo
wfC: PC_wf C
Hpiffq: Γ ⊢i p <---> q using gpi
H: well_formed (C [q])
→ wf (patterns_of l)
  → Γ ⊢i foldr patt_imp (C [q]) (patterns_of l)
    using gpi
pile: ProofInfoLe
  (ExGen := list_to_set
              (evar_fresh_seq
                 (free_evars (pcPattern C)
                  ∪ free_evars p ∪ 
                  free_evars q ∪ {[
                  pcEvar C]})
                 (maximal_exists_depth_to 0
                    (pcEvar C) 
                    (pcPattern C))),
   SVSubst := list_to_set
                (svar_fresh_seq
                   (free_svars (pcPattern C)
                    ∪ free_svars p
                    ∪ free_svars q)
                   (maximal_mu_depth_to 0
                      (pcEvar C) 
                      (pcPattern C))),
   KT := mu_in_evar_path 
           (pcEvar C) (pcPattern C) 0) gpi
wfcp: well_formed (C [p])
wfl: wf (patterns_of l)
well_formed (C [q])
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
l: hypotheses
gpi: ProofInfo
wfC: PC_wf C
Hpiffq: Γ ⊢i p <---> q using gpi
H: well_formed (C [q])
→ wf (patterns_of l)
  → Γ ⊢i foldr patt_imp (C [q]) (patterns_of l)
    using gpi
pile: ProofInfoLe
  (ExGen := list_to_set
              (evar_fresh_seq
                 (free_evars (pcPattern C)
                  ∪ free_evars p ∪ 
                  free_evars q ∪ {[
                  pcEvar C]})
                 (maximal_exists_depth_to 0
                    (pcEvar C) 
                    (pcPattern C))),
   SVSubst := list_to_set
                (svar_fresh_seq
                   (free_svars (pcPattern C)
                    ∪ free_svars p
                    ∪ free_svars q)
                   (maximal_mu_depth_to 0
                      (pcEvar C) 
                      (pcPattern C))),
   KT := mu_in_evar_path 
           (pcEvar C) (pcPattern C) 0) gpi
wfcp: well_formed (C [p])
wfl: wf (patterns_of l)
wf (patterns_of l)
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
l: hypotheses
gpi: ProofInfo
wfC: PC_wf C
Hpiffq: Γ ⊢i p <---> q using gpi
H: Γ ⊢i foldr patt_imp (C [q]) (patterns_of l)
using gpi
pile: ProofInfoLe
  (ExGen := list_to_set
              (evar_fresh_seq
                 (free_evars (pcPattern C)
                  ∪ free_evars p ∪ 
                  free_evars q ∪ {[
                  pcEvar C]})
                 (maximal_exists_depth_to 0
                    (pcEvar C) 
                    (pcPattern C))),
   SVSubst := list_to_set
                (svar_fresh_seq
                   (free_svars (pcPattern C)
                    ∪ free_svars p
                    ∪ free_svars q)
                   (maximal_mu_depth_to 0
                      (pcEvar C) 
                      (pcPattern C))),
   KT := mu_in_evar_path 
           (pcEvar C) (pcPattern C) 0) gpi
wfcp: well_formed (C [p])
wfl: wf (patterns_of l)
Γ ⊢i foldr patt_imp (C [p]) (patterns_of l) using gpi
  {
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
l: hypotheses
gpi: ProofInfo
wfC: PC_wf C
Hpiffq: Γ ⊢i p <---> q using gpi
H: well_formed (C [q])
→ wf (patterns_of l)
  → Γ ⊢i foldr patt_imp (C [q]) (patterns_of l)
    using gpi
pile: ProofInfoLe
  (ExGen := list_to_set
              (evar_fresh_seq
                 (free_evars (pcPattern C)
                  ∪ free_evars p ∪ 
                  free_evars q ∪ {[
                  pcEvar C]})
                 (maximal_exists_depth_to 0
                    (pcEvar C) 
                    (pcPattern C))),
   SVSubst := list_to_set
                (svar_fresh_seq
                   (free_svars (pcPattern C)
                    ∪ free_svars p
                    ∪ free_svars q)
                   (maximal_mu_depth_to 0
                      (pcEvar C) 
                      (pcPattern C))),
   KT := mu_in_evar_path 
           (pcEvar C) (pcPattern C) 0) gpi
wfcp: well_formed (C [p])
wfl: wf (patterns_of l)
well_formed (C [q]) abstract (
      pose proof (Hwfiff := proved_impl_wf _ _ (proj1_sig Hpiffq));
      unfold emplace;
      apply well_formed_free_evar_subst_0;[wf_auto2|];
      fold (PC_wf C);
      eapply wf_emplaced_impl_wf_context;
      apply wfcp
    ).
  }
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
l: hypotheses
gpi: ProofInfo
wfC: PC_wf C
Hpiffq: Γ ⊢i p <---> q using gpi
H: well_formed (C [q])
→ wf (patterns_of l)
  → Γ ⊢i foldr patt_imp (C [q]) (patterns_of l)
    using gpi
pile: ProofInfoLe
  (ExGen := list_to_set
              (evar_fresh_seq
                 (free_evars (pcPattern C)
                  ∪ free_evars p ∪ 
                  free_evars q ∪ {[
                  pcEvar C]})
                 (maximal_exists_depth_to 0
                    (pcEvar C) 
                    (pcPattern C))),
   SVSubst := list_to_set
                (svar_fresh_seq
                   (free_svars (pcPattern C)
                    ∪ free_svars p
                    ∪ free_svars q)
                   (maximal_mu_depth_to 0
                      (pcEvar C) 
                      (pcPattern C))),
   KT := mu_in_evar_path 
           (pcEvar C) (pcPattern C) 0) gpi
wfcp: well_formed (C [p])
wfl: wf (patterns_of l)
wf (patterns_of l)
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
l: hypotheses
gpi: ProofInfo
wfC: PC_wf C
Hpiffq: Γ ⊢i p <---> q using gpi
H: Γ ⊢i foldr patt_imp (C [q]) (patterns_of l)
using gpi
pile: ProofInfoLe
  (ExGen := list_to_set
              (evar_fresh_seq
                 (free_evars (pcPattern C)
                  ∪ free_evars p ∪ 
                  free_evars q ∪ {[
                  pcEvar C]})
                 (maximal_exists_depth_to 0
                    (pcEvar C) 
                    (pcPattern C))),
   SVSubst := list_to_set
                (svar_fresh_seq
                   (free_svars (pcPattern C)
                    ∪ free_svars p
                    ∪ free_svars q)
                   (maximal_mu_depth_to 0
                      (pcEvar C) 
                      (pcPattern C))),
   KT := mu_in_evar_path 
           (pcEvar C) (pcPattern C) 0) gpi
wfcp: well_formed (C [p])
wfl: wf (patterns_of l)
Γ ⊢i foldr patt_imp (C [p]) (patterns_of l) using gpi
  {
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
l: hypotheses
gpi: ProofInfo
wfC: PC_wf C
Hpiffq: Γ ⊢i p <---> q using gpi
H: well_formed (C [q])
→ wf (patterns_of l)
  → Γ ⊢i foldr patt_imp (C [q]) (patterns_of l)
    using gpi
pile: ProofInfoLe
  (ExGen := list_to_set
              (evar_fresh_seq
                 (free_evars (pcPattern C)
                  ∪ free_evars p ∪ 
                  free_evars q ∪ {[
                  pcEvar C]})
                 (maximal_exists_depth_to 0
                    (pcEvar C) 
                    (pcPattern C))),
   SVSubst := list_to_set
                (svar_fresh_seq
                   (free_svars (pcPattern C)
                    ∪ free_svars p
                    ∪ free_svars q)
                   (maximal_mu_depth_to 0
                      (pcEvar C) 
                      (pcPattern C))),
   KT := mu_in_evar_path 
           (pcEvar C) (pcPattern C) 0) gpi
wfcp: well_formed (C [p])
wfl: wf (patterns_of l)
wf (patterns_of l) exact wfl. }
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
l: hypotheses
gpi: ProofInfo
wfC: PC_wf C
Hpiffq: Γ ⊢i p <---> q using gpi
H: Γ ⊢i foldr patt_imp (C [q]) (patterns_of l)
using gpi
pile: ProofInfoLe
  (ExGen := list_to_set
              (evar_fresh_seq
                 (free_evars (pcPattern C)
                  ∪ free_evars p ∪ 
                  free_evars q ∪ {[
                  pcEvar C]})
                 (maximal_exists_depth_to 0
                    (pcEvar C) 
                    (pcPattern C))),
   SVSubst := list_to_set
                (svar_fresh_seq
                   (free_svars (pcPattern C)
                    ∪ free_svars p
                    ∪ free_svars q)
                   (maximal_mu_depth_to 0
                      (pcEvar C) 
                      (pcPattern C))),
   KT := mu_in_evar_path 
           (pcEvar C) (pcPattern C) 0) gpi
wfcp: well_formed (C [p])
wfl: wf (patterns_of l)
Γ ⊢i foldr patt_imp (C [p]) (patterns_of l) using gpi

  eapply MP.
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
l: hypotheses
gpi: ProofInfo
wfC: PC_wf C
Hpiffq: Γ ⊢i p <---> q using gpi
H: Γ ⊢i foldr patt_imp (C [q]) (patterns_of l)
using gpi
pile: ProofInfoLe
  (ExGen := list_to_set
              (evar_fresh_seq
                 (free_evars (pcPattern C)
                  ∪ free_evars p ∪ 
                  free_evars q ∪ {[
                  pcEvar C]})
                 (maximal_exists_depth_to 0
                    (pcEvar C) 
                    (pcPattern C))),
   SVSubst := list_to_set
                (svar_fresh_seq
                   (free_svars (pcPattern C)
                    ∪ free_svars p
                    ∪ free_svars q)
                   (maximal_mu_depth_to 0
                      (pcEvar C) 
                      (pcPattern C))),
   KT := mu_in_evar_path 
           (pcEvar C) (pcPattern C) 0) gpi
wfcp: well_formed (C [p])
wfl: wf (patterns_of l)
Γ ⊢i ?ϕ₁ using gpi
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
l: hypotheses
gpi: ProofInfo
wfC: PC_wf C
Hpiffq: Γ ⊢i p <---> q using gpi
H: Γ ⊢i foldr patt_imp (C [q]) (patterns_of l)
using gpi
pile: ProofInfoLe
  (ExGen := list_to_set
              (evar_fresh_seq
                 (free_evars (pcPattern C)
                  ∪ free_evars p ∪ 
                  free_evars q ∪ {[
                  pcEvar C]})
                 (maximal_exists_depth_to 0
                    (pcEvar C) 
                    (pcPattern C))),
   SVSubst := list_to_set
                (svar_fresh_seq
                   (free_svars (pcPattern C)
                    ∪ free_svars p
                    ∪ free_svars q)
                   (maximal_mu_depth_to 0
                      (pcEvar C) 
                      (pcPattern C))),
   KT := mu_in_evar_path 
           (pcEvar C) (pcPattern C) 0) gpi
wfcp: well_formed (C [p])
wfl: wf (patterns_of l)
Γ ⊢i ?ϕ₁ ---> foldr patt_imp (C [p]) (patterns_of l)
using gpi
  2: apply pf_iff_proj2.
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
l: hypotheses
gpi: ProofInfo
wfC: PC_wf C
Hpiffq: Γ ⊢i p <---> q using gpi
H: Γ ⊢i foldr patt_imp (C [q]) (patterns_of l)
using gpi
pile: ProofInfoLe
  (ExGen := list_to_set
              (evar_fresh_seq
                 (free_evars (pcPattern C)
                  ∪ free_evars p ∪ 
                  free_evars q ∪ {[
                  pcEvar C]})
                 (maximal_exists_depth_to 0
                    (pcEvar C) 
                    (pcPattern C))),
   SVSubst := list_to_set
                (svar_fresh_seq
                   (free_svars (pcPattern C)
                    ∪ free_svars p
                    ∪ free_svars q)
                   (maximal_mu_depth_to 0
                      (pcEvar C) 
                      (pcPattern C))),
   KT := mu_in_evar_path 
           (pcEvar C) (pcPattern C) 0) gpi
wfcp: well_formed (C [p])
wfl: wf (patterns_of l)
Γ ⊢i ?ϕ₁ using gpi
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
l: hypotheses
gpi: ProofInfo
wfC: PC_wf C
Hpiffq: Γ ⊢i p <---> q using gpi
H: Γ ⊢i foldr patt_imp (C [q]) (patterns_of l)
using gpi
pile: ProofInfoLe
  (ExGen := list_to_set
              (evar_fresh_seq
                 (free_evars (pcPattern C)
                  ∪ free_evars p ∪ 
                  free_evars q ∪ {[
                  pcEvar C]})
                 (maximal_exists_depth_to 0
                    (pcEvar C) 
                    (pcPattern C))),
   SVSubst := list_to_set
                (svar_fresh_seq
                   (free_svars (pcPattern C)
                    ∪ free_svars p
                    ∪ free_svars q)
                   (maximal_mu_depth_to 0
                      (pcEvar C) 
                      (pcPattern C))),
   KT := mu_in_evar_path 
           (pcEvar C) (pcPattern C) 0) gpi
wfcp: well_formed (C [p])
wfl: wf (patterns_of l)
well_formed (foldr patt_imp (C [p]) (patterns_of l))
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
l: hypotheses
gpi: ProofInfo
wfC: PC_wf C
Hpiffq: Γ ⊢i p <---> q using gpi
H: Γ ⊢i foldr patt_imp (C [q]) (patterns_of l)
using gpi
pile: ProofInfoLe
  (ExGen := list_to_set
              (evar_fresh_seq
                 (free_evars (pcPattern C)
                  ∪ free_evars p ∪ 
                  free_evars q ∪ {[
                  pcEvar C]})
                 (maximal_exists_depth_to 0
                    (pcEvar C) 
                    (pcPattern C))),
   SVSubst := list_to_set
                (svar_fresh_seq
                   (free_svars (pcPattern C)
                    ∪ free_svars p
                    ∪ free_svars q)
                   (maximal_mu_depth_to 0
                      (pcEvar C) 
                      (pcPattern C))),
   KT := mu_in_evar_path 
           (pcEvar C) (pcPattern C) 0) gpi
wfcp: well_formed (C [p])
wfl: wf (patterns_of l)
well_formed ?ϕ₁
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
l: hypotheses
gpi: ProofInfo
wfC: PC_wf C
Hpiffq: Γ ⊢i p <---> q using gpi
H: Γ ⊢i foldr patt_imp (C [q]) (patterns_of l)
using gpi
pile: ProofInfoLe
  (ExGen := list_to_set
              (evar_fresh_seq
                 (free_evars (pcPattern C)
                  ∪ free_evars p ∪ 
                  free_evars q ∪ {[
                  pcEvar C]})
                 (maximal_exists_depth_to 0
                    (pcEvar C) 
                    (pcPattern C))),
   SVSubst := list_to_set
                (svar_fresh_seq
                   (free_svars (pcPattern C)
                    ∪ free_svars p
                    ∪ free_svars q)
                   (maximal_mu_depth_to 0
                      (pcEvar C) 
                      (pcPattern C))),
   KT := mu_in_evar_path 
           (pcEvar C) (pcPattern C) 0) gpi
wfcp: well_formed (C [p])
wfl: wf (patterns_of l)
Γ ⊢i foldr patt_imp (C [p]) (patterns_of l) <---> ?ϕ₁
using gpi
  2: abstract (wf_auto2).
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
l: hypotheses
gpi: ProofInfo
wfC: PC_wf C
Hpiffq: Γ ⊢i p <---> q using gpi
H: Γ ⊢i foldr patt_imp (C [q]) (patterns_of l)
using gpi
pile: ProofInfoLe
  (ExGen := list_to_set
              (evar_fresh_seq
                 (free_evars (pcPattern C)
                  ∪ free_evars p ∪ 
                  free_evars q ∪ {[
                  pcEvar C]})
                 (maximal_exists_depth_to 0
                    (pcEvar C) 
                    (pcPattern C))),
   SVSubst := list_to_set
                (svar_fresh_seq
                   (free_svars (pcPattern C)
                    ∪ free_svars p
                    ∪ free_svars q)
                   (maximal_mu_depth_to 0
                      (pcEvar C) 
                      (pcPattern C))),
   KT := mu_in_evar_path 
           (pcEvar C) (pcPattern C) 0) gpi
wfcp: well_formed (C [p])
wfl: wf (patterns_of l)
Γ ⊢i ?ϕ₁ using gpi
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
l: hypotheses
gpi: ProofInfo
wfC: PC_wf C
Hpiffq: Γ ⊢i p <---> q using gpi
H: Γ ⊢i foldr patt_imp (C [q]) (patterns_of l)
using gpi
pile: ProofInfoLe
  (ExGen := list_to_set
              (evar_fresh_seq
                 (free_evars (pcPattern C)
                  ∪ free_evars p ∪ 
                  free_evars q ∪ {[
                  pcEvar C]})
                 (maximal_exists_depth_to 0
                    (pcEvar C) 
                    (pcPattern C))),
   SVSubst := list_to_set
                (svar_fresh_seq
                   (free_svars (pcPattern C)
                    ∪ free_svars p
                    ∪ free_svars q)
                   (maximal_mu_depth_to 0
                      (pcEvar C) 
                      (pcPattern C))),
   KT := mu_in_evar_path 
           (pcEvar C) (pcPattern C) 0) gpi
wfcp: well_formed (C [p])
wfl: wf (patterns_of l)
well_formed ?ϕ₁
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
l: hypotheses
gpi: ProofInfo
wfC: PC_wf C
Hpiffq: Γ ⊢i p <---> q using gpi
H: Γ ⊢i foldr patt_imp (C [q]) (patterns_of l)
using gpi
pile: ProofInfoLe
  (ExGen := list_to_set
              (evar_fresh_seq
                 (free_evars (pcPattern C)
                  ∪ free_evars p ∪ 
                  free_evars q ∪ {[
                  pcEvar C]})
                 (maximal_exists_depth_to 0
                    (pcEvar C) 
                    (pcPattern C))),
   SVSubst := list_to_set
                (svar_fresh_seq
                   (free_svars (pcPattern C)
                    ∪ free_svars p
                    ∪ free_svars q)
                   (maximal_mu_depth_to 0
                      (pcEvar C) 
                      (pcPattern C))),
   KT := mu_in_evar_path 
           (pcEvar C) (pcPattern C) 0) gpi
wfcp: well_formed (C [p])
wfl: wf (patterns_of l)
Γ ⊢i foldr patt_imp (C [p]) (patterns_of l) <---> ?ϕ₁
using gpi
  3: eapply prf_equiv_congruence_iter.
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
l: hypotheses
gpi: ProofInfo
wfC: PC_wf C
Hpiffq: Γ ⊢i p <---> q using gpi
H: Γ ⊢i foldr patt_imp (C [q]) (patterns_of l)
using gpi
pile: ProofInfoLe
  (ExGen := list_to_set
              (evar_fresh_seq
                 (free_evars (pcPattern C)
                  ∪ free_evars p ∪ 
                  free_evars q ∪ {[
                  pcEvar C]})
                 (maximal_exists_depth_to 0
                    (pcEvar C) 
                    (pcPattern C))),
   SVSubst := list_to_set
                (svar_fresh_seq
                   (free_svars (pcPattern C)
                    ∪ free_svars p
                    ∪ free_svars q)
                   (maximal_mu_depth_to 0
                      (pcEvar C) 
                      (pcPattern C))),
   KT := mu_in_evar_path 
           (pcEvar C) (pcPattern C) 0) gpi
wfcp: well_formed (C [p])
wfl: wf (patterns_of l)
Γ ⊢i foldr patt_imp (C [?q]) (patterns_of l) using gpi
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
l: hypotheses
gpi: ProofInfo
wfC: PC_wf C
Hpiffq: Γ ⊢i p <---> q using gpi
H: Γ ⊢i foldr patt_imp (C [q]) (patterns_of l)
using gpi
pile: ProofInfoLe
  (ExGen := list_to_set
              (evar_fresh_seq
                 (free_evars (pcPattern C)
                  ∪ free_evars p ∪ 
                  free_evars q ∪ {[
                  pcEvar C]})
                 (maximal_exists_depth_to 0
                    (pcEvar C) 
                    (pcPattern C))),
   SVSubst := list_to_set
                (svar_fresh_seq
                   (free_svars (pcPattern C)
                    ∪ free_svars p
                    ∪ free_svars q)
                   (maximal_mu_depth_to 0
                      (pcEvar C) 
                      (pcPattern C))),
   KT := mu_in_evar_path 
           (pcEvar C) (pcPattern C) 0) gpi
wfcp: well_formed (C [p])
wfl: wf (patterns_of l)
well_formed (foldr patt_imp (C [?q]) (patterns_of l))
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
l: hypotheses
gpi: ProofInfo
wfC: PC_wf C
Hpiffq: Γ ⊢i p <---> q using gpi
H: Γ ⊢i foldr patt_imp (C [q]) (patterns_of l)
using gpi
pile: ProofInfoLe
  (ExGen := list_to_set
              (evar_fresh_seq
                 (free_evars (pcPattern C)
                  ∪ free_evars p ∪ 
                  free_evars q ∪ {[
                  pcEvar C]})
                 (maximal_exists_depth_to 0
                    (pcEvar C) 
                    (pcPattern C))),
   SVSubst := list_to_set
                (svar_fresh_seq
                   (free_svars (pcPattern C)
                    ∪ free_svars p
                    ∪ free_svars q)
                   (maximal_mu_depth_to 0
                      (pcEvar C) 
                      (pcPattern C))),
   KT := mu_in_evar_path 
           (pcEvar C) (pcPattern C) 0) gpi
wfcp: well_formed (C [p])
wfl: wf (patterns_of l)
well_formed p
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
l: hypotheses
gpi: ProofInfo
wfC: PC_wf C
Hpiffq: Γ ⊢i p <---> q using gpi
H: Γ ⊢i foldr patt_imp (C [q]) (patterns_of l)
using gpi
pile: ProofInfoLe
  (ExGen := list_to_set
              (evar_fresh_seq
                 (free_evars (pcPattern C)
                  ∪ free_evars p ∪ 
                  free_evars q ∪ {[
                  pcEvar C]})
                 (maximal_exists_depth_to 0
                    (pcEvar C) 
                    (pcPattern C))),
   SVSubst := list_to_set
                (svar_fresh_seq
                   (free_svars (pcPattern C)
                    ∪ free_svars p
                    ∪ free_svars q)
                   (maximal_mu_depth_to 0
                      (pcEvar C) 
                      (pcPattern C))),
   KT := mu_in_evar_path 
           (pcEvar C) (pcPattern C) 0) gpi
wfcp: well_formed (C [p])
wfl: wf (patterns_of l)
well_formed ?q
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
l: hypotheses
gpi: ProofInfo
wfC: PC_wf C
Hpiffq: Γ ⊢i p <---> q using gpi
H: Γ ⊢i foldr patt_imp (C [q]) (patterns_of l)
using gpi
pile: ProofInfoLe
  (ExGen := list_to_set
              (evar_fresh_seq
                 (free_evars (pcPattern C)
                  ∪ free_evars p ∪ 
                  free_evars q ∪ {[
                  pcEvar C]})
                 (maximal_exists_depth_to 0
                    (pcEvar C) 
                    (pcPattern C))),
   SVSubst := list_to_set
                (svar_fresh_seq
                   (free_svars (pcPattern C)
                    ∪ free_svars p
                    ∪ free_svars q)
                   (maximal_mu_depth_to 0
                      (pcEvar C) 
                      (pcPattern C))),
   KT := mu_in_evar_path 
           (pcEvar C) (pcPattern C) 0) gpi
wfcp: well_formed (C [p])
wfl: wf (patterns_of l)
PC_wf C
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
l: hypotheses
gpi: ProofInfo
wfC: PC_wf C
Hpiffq: Γ ⊢i p <---> q using gpi
H: Γ ⊢i foldr patt_imp (C [q]) (patterns_of l)
using gpi
pile: ProofInfoLe
  (ExGen := list_to_set
              (evar_fresh_seq
                 (free_evars (pcPattern C)
                  ∪ free_evars p ∪ 
                  free_evars q ∪ {[
                  pcEvar C]})
                 (maximal_exists_depth_to 0
                    (pcEvar C) 
                    (pcPattern C))),
   SVSubst := list_to_set
                (svar_fresh_seq
                   (free_svars (pcPattern C)
                    ∪ free_svars p
                    ∪ free_svars q)
                   (maximal_mu_depth_to 0
                      (pcEvar C) 
                      (pcPattern C))),
   KT := mu_in_evar_path 
           (pcEvar C) (pcPattern C) 0) gpi
wfcp: well_formed (C [p])
wfl: wf (patterns_of l)
ProofInfoLe
  (ExGen := list_to_set
              (evar_fresh_seq
                 (free_evars (pcPattern C)
                  ∪ free_evars p ∪ 
                  free_evars ?q ∪ {[
                  pcEvar C]})
                 (maximal_exists_depth_to 0 
                    (pcEvar C) 
                    (pcPattern C))),
   SVSubst := list_to_set
                (svar_fresh_seq
                   (free_svars (pcPattern C)
                    ∪ free_svars p ∪ 
                    free_svars ?q)
                   (maximal_mu_depth_to 0 
                      (pcEvar C) 
                      (pcPattern C))),
   KT := mu_in_evar_path (pcEvar C) (pcPattern C) 0)
  gpi
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
l: hypotheses
gpi: ProofInfo
wfC: PC_wf C
Hpiffq: Γ ⊢i p <---> q using gpi
H: Γ ⊢i foldr patt_imp (C [q]) (patterns_of l)
using gpi
pile: ProofInfoLe
  (ExGen := list_to_set
              (evar_fresh_seq
                 (free_evars (pcPattern C)
                  ∪ free_evars p ∪ 
                  free_evars q ∪ {[
                  pcEvar C]})
                 (maximal_exists_depth_to 0
                    (pcEvar C) 
                    (pcPattern C))),
   SVSubst := list_to_set
                (svar_fresh_seq
                   (free_svars (pcPattern C)
                    ∪ free_svars p
                    ∪ free_svars q)
                   (maximal_mu_depth_to 0
                      (pcEvar C) 
                      (pcPattern C))),
   KT := mu_in_evar_path 
           (pcEvar C) (pcPattern C) 0) gpi
wfcp: well_formed (C [p])
wfl: wf (patterns_of l)
wf (patterns_of l)
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
l: hypotheses
gpi: ProofInfo
wfC: PC_wf C
Hpiffq: Γ ⊢i p <---> q using gpi
H: Γ ⊢i foldr patt_imp (C [q]) (patterns_of l)
using gpi
pile: ProofInfoLe
  (ExGen := list_to_set
              (evar_fresh_seq
                 (free_evars (pcPattern C)
                  ∪ free_evars p ∪ 
                  free_evars q ∪ {[
                  pcEvar C]})
                 (maximal_exists_depth_to 0
                    (pcEvar C) 
                    (pcPattern C))),
   SVSubst := list_to_set
                (svar_fresh_seq
                   (free_svars (pcPattern C)
                    ∪ free_svars p
                    ∪ free_svars q)
                   (maximal_mu_depth_to 0
                      (pcEvar C) 
                      (pcPattern C))),
   KT := mu_in_evar_path 
           (pcEvar C) (pcPattern C) 0) gpi
wfcp: well_formed (C [p])
wfl: wf (patterns_of l)
Γ ⊢i p <---> ?q using gpi
  8: apply Hpiffq.
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
l: hypotheses
gpi: ProofInfo
wfC: PC_wf C
Hpiffq: Γ ⊢i p <---> q using gpi
H: Γ ⊢i foldr patt_imp (C [q]) (patterns_of l)
using gpi
pile: ProofInfoLe
  (ExGen := list_to_set
              (evar_fresh_seq
                 (free_evars (pcPattern C)
                  ∪ free_evars p ∪ 
                  free_evars q ∪ {[
                  pcEvar C]})
                 (maximal_exists_depth_to 0
                    (pcEvar C) 
                    (pcPattern C))),
   SVSubst := list_to_set
                (svar_fresh_seq
                   (free_svars (pcPattern C)
                    ∪ free_svars p
                    ∪ free_svars q)
                   (maximal_mu_depth_to 0
                      (pcEvar C) 
                      (pcPattern C))),
   KT := mu_in_evar_path 
           (pcEvar C) (pcPattern C) 0) gpi
wfcp: well_formed (C [p])
wfl: wf (patterns_of l)
Γ ⊢i foldr patt_imp (C [q]) (patterns_of l) using gpi
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
l: hypotheses
gpi: ProofInfo
wfC: PC_wf C
Hpiffq: Γ ⊢i p <---> q using gpi
H: Γ ⊢i foldr patt_imp (C [q]) (patterns_of l)
using gpi
pile: ProofInfoLe
  (ExGen := list_to_set
              (evar_fresh_seq
                 (free_evars (pcPattern C)
                  ∪ free_evars p ∪ 
                  free_evars q ∪ {[
                  pcEvar C]})
                 (maximal_exists_depth_to 0
                    (pcEvar C) 
                    (pcPattern C))),
   SVSubst := list_to_set
                (svar_fresh_seq
                   (free_svars (pcPattern C)
                    ∪ free_svars p
                    ∪ free_svars q)
                   (maximal_mu_depth_to 0
                      (pcEvar C) 
                      (pcPattern C))),
   KT := mu_in_evar_path 
           (pcEvar C) (pcPattern C) 0) gpi
wfcp: well_formed (C [p])
wfl: wf (patterns_of l)
well_formed (foldr patt_imp (C [q]) (patterns_of l))
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
l: hypotheses
gpi: ProofInfo
wfC: PC_wf C
Hpiffq: Γ ⊢i p <---> q using gpi
H: Γ ⊢i foldr patt_imp (C [q]) (patterns_of l)
using gpi
pile: ProofInfoLe
  (ExGen := list_to_set
              (evar_fresh_seq
                 (free_evars (pcPattern C)
                  ∪ free_evars p ∪ 
                  free_evars q ∪ {[
                  pcEvar C]})
                 (maximal_exists_depth_to 0
                    (pcEvar C) 
                    (pcPattern C))),
   SVSubst := list_to_set
                (svar_fresh_seq
                   (free_svars (pcPattern C)
                    ∪ free_svars p
                    ∪ free_svars q)
                   (maximal_mu_depth_to 0
                      (pcEvar C) 
                      (pcPattern C))),
   KT := mu_in_evar_path 
           (pcEvar C) (pcPattern C) 0) gpi
wfcp: well_formed (C [p])
wfl: wf (patterns_of l)
well_formed p
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
l: hypotheses
gpi: ProofInfo
wfC: PC_wf C
Hpiffq: Γ ⊢i p <---> q using gpi
H: Γ ⊢i foldr patt_imp (C [q]) (patterns_of l)
using gpi
pile: ProofInfoLe
  (ExGen := list_to_set
              (evar_fresh_seq
                 (free_evars (pcPattern C)
                  ∪ free_evars p ∪ 
                  free_evars q ∪ {[
                  pcEvar C]})
                 (maximal_exists_depth_to 0
                    (pcEvar C) 
                    (pcPattern C))),
   SVSubst := list_to_set
                (svar_fresh_seq
                   (free_svars (pcPattern C)
                    ∪ free_svars p
                    ∪ free_svars q)
                   (maximal_mu_depth_to 0
                      (pcEvar C) 
                      (pcPattern C))),
   KT := mu_in_evar_path 
           (pcEvar C) (pcPattern C) 0) gpi
wfcp: well_formed (C [p])
wfl: wf (patterns_of l)
well_formed q
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
l: hypotheses
gpi: ProofInfo
wfC: PC_wf C
Hpiffq: Γ ⊢i p <---> q using gpi
H: Γ ⊢i foldr patt_imp (C [q]) (patterns_of l)
using gpi
pile: ProofInfoLe
  (ExGen := list_to_set
              (evar_fresh_seq
                 (free_evars (pcPattern C)
                  ∪ free_evars p ∪ 
                  free_evars q ∪ {[
                  pcEvar C]})
                 (maximal_exists_depth_to 0
                    (pcEvar C) 
                    (pcPattern C))),
   SVSubst := list_to_set
                (svar_fresh_seq
                   (free_svars (pcPattern C)
                    ∪ free_svars p
                    ∪ free_svars q)
                   (maximal_mu_depth_to 0
                      (pcEvar C) 
                      (pcPattern C))),
   KT := mu_in_evar_path 
           (pcEvar C) (pcPattern C) 0) gpi
wfcp: well_formed (C [p])
wfl: wf (patterns_of l)
PC_wf C
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
l: hypotheses
gpi: ProofInfo
wfC: PC_wf C
Hpiffq: Γ ⊢i p <---> q using gpi
H: Γ ⊢i foldr patt_imp (C [q]) (patterns_of l)
using gpi
pile: ProofInfoLe
  (ExGen := list_to_set
              (evar_fresh_seq
                 (free_evars (pcPattern C)
                  ∪ free_evars p ∪ 
                  free_evars q ∪ {[
                  pcEvar C]})
                 (maximal_exists_depth_to 0
                    (pcEvar C) 
                    (pcPattern C))),
   SVSubst := list_to_set
                (svar_fresh_seq
                   (free_svars (pcPattern C)
                    ∪ free_svars p
                    ∪ free_svars q)
                   (maximal_mu_depth_to 0
                      (pcEvar C) 
                      (pcPattern C))),
   KT := mu_in_evar_path 
           (pcEvar C) (pcPattern C) 0) gpi
wfcp: well_formed (C [p])
wfl: wf (patterns_of l)
ProofInfoLe
  (ExGen := list_to_set
              (evar_fresh_seq
                 (free_evars (pcPattern C)
                  ∪ free_evars p ∪ 
                  free_evars q ∪ {[
                  pcEvar C]})
                 (maximal_exists_depth_to 0 
                    (pcEvar C) 
                    (pcPattern C))),
   SVSubst := list_to_set
                (svar_fresh_seq
                   (free_svars (pcPattern C)
                    ∪ free_svars p ∪ 
                    free_svars q)
                   (maximal_mu_depth_to 0 
                      (pcEvar C) 
                      (pcPattern C))),
   KT := mu_in_evar_path (pcEvar C) (pcPattern C) 0)
  gpi
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
l: hypotheses
gpi: ProofInfo
wfC: PC_wf C
Hpiffq: Γ ⊢i p <---> q using gpi
H: Γ ⊢i foldr patt_imp (C [q]) (patterns_of l)
using gpi
pile: ProofInfoLe
  (ExGen := list_to_set
              (evar_fresh_seq
                 (free_evars (pcPattern C)
                  ∪ free_evars p ∪ 
                  free_evars q ∪ {[
                  pcEvar C]})
                 (maximal_exists_depth_to 0
                    (pcEvar C) 
                    (pcPattern C))),
   SVSubst := list_to_set
                (svar_fresh_seq
                   (free_svars (pcPattern C)
                    ∪ free_svars p
                    ∪ free_svars q)
                   (maximal_mu_depth_to 0
                      (pcEvar C) 
                      (pcPattern C))),
   KT := mu_in_evar_path 
           (pcEvar C) (pcPattern C) 0) gpi
wfcp: well_formed (C [p])
wfl: wf (patterns_of l)
wf (patterns_of l)
  all: try assumption.
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
l: hypotheses
gpi: ProofInfo
wfC: PC_wf C
Hpiffq: Γ ⊢i p <---> q using gpi
H: Γ ⊢i foldr patt_imp (C [q]) (patterns_of l)
using gpi
pile: ProofInfoLe
  (ExGen := list_to_set
              (evar_fresh_seq
                 (free_evars (pcPattern C)
                  ∪ free_evars p ∪ 
                  free_evars q ∪ {[
                  pcEvar C]})
                 (maximal_exists_depth_to 0
                    (pcEvar C) 
                    (pcPattern C))),
   SVSubst := list_to_set
                (svar_fresh_seq
                   (free_svars (pcPattern C)
                    ∪ free_svars p
                    ∪ free_svars q)
                   (maximal_mu_depth_to 0
                      (pcEvar C) 
                      (pcPattern C))),
   KT := mu_in_evar_path 
           (pcEvar C) (pcPattern C) 0) gpi
wfcp: well_formed (C [p])
wfl: wf (patterns_of l)
well_formed (foldr patt_imp (C [q]) (patterns_of l))
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
l: hypotheses
gpi: ProofInfo
wfC: PC_wf C
Hpiffq: Γ ⊢i p <---> q using gpi
H: Γ ⊢i foldr patt_imp (C [q]) (patterns_of l)
using gpi
pile: ProofInfoLe
  (ExGen := list_to_set
              (evar_fresh_seq
                 (free_evars (pcPattern C)
                  ∪ free_evars p ∪ 
                  free_evars q ∪ {[
                  pcEvar C]})
                 (maximal_exists_depth_to 0
                    (pcEvar C) 
                    (pcPattern C))),
   SVSubst := list_to_set
                (svar_fresh_seq
                   (free_svars (pcPattern C)
                    ∪ free_svars p
                    ∪ free_svars q)
                   (maximal_mu_depth_to 0
                      (pcEvar C) 
                      (pcPattern C))),
   KT := mu_in_evar_path 
           (pcEvar C) (pcPattern C) 0) gpi
wfcp: well_formed (C [p])
wfl: wf (patterns_of l)
well_formed p
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
l: hypotheses
gpi: ProofInfo
wfC: PC_wf C
Hpiffq: Γ ⊢i p <---> q using gpi
H: Γ ⊢i foldr patt_imp (C [q]) (patterns_of l)
using gpi
pile: ProofInfoLe
  (ExGen := list_to_set
              (evar_fresh_seq
                 (free_evars (pcPattern C)
                  ∪ free_evars p ∪ 
                  free_evars q ∪ {[
                  pcEvar C]})
                 (maximal_exists_depth_to 0
                    (pcEvar C) 
                    (pcPattern C))),
   SVSubst := list_to_set
                (svar_fresh_seq
                   (free_svars (pcPattern C)
                    ∪ free_svars p
                    ∪ free_svars q)
                   (maximal_mu_depth_to 0
                      (pcEvar C) 
                      (pcPattern C))),
   KT := mu_in_evar_path 
           (pcEvar C) (pcPattern C) 0) gpi
wfcp: well_formed (C [p])
wfl: wf (patterns_of l)
well_formed q
  all: wf_auto2.
Defined.



Ltac2 mutable ml_debug_rewrite := false.

(* Calls [cont] for every subpattern [a] of pattern [phi], giving the match context as an argument *)
Ltac2 for_each_match := fun (a : constr) (phi : constr) (cont : Pattern.context -> unit) =>
  try (
      if ml_debug_rewrite then
           Message.print (
               Message.concat
                 (Message.of_string "Trying to match ")
                 (Message.of_constr a)
             )
        else ();
      match! phi with
      | context ctx [ ?x ]
        => if ml_debug_rewrite then
             Message.print (
                 Message.concat
                   (Message.of_string " against ")
                   (Message.of_constr x)
               )
           else ();
           (if Constr.equal x a then
              if ml_debug_rewrite then
                Message.print (Message.of_string "Success.")
              else () ;
              cont ctx
            else ());
           fail (* backtrack *)
      end
    ); ().

(* Calls [cont] for [n]th subpatern [a] of pattern [phi]. *)
Ltac2 for_nth_match :=
  fun (n : int) (a : constr) (phi : constr) (cont : Pattern.context -> unit) =>
    if ml_debug_rewrite then
      Message.print (Message.of_string "for_nth_match")
    else () ;
    let curr : int ref := {contents := 0} in
    let found : bool ref := {contents := false} in
    for_each_match a phi
    (fun ctx =>
      if (found.(contents))
      then ()
      else
        curr.(contents) := Int.add 1 (curr.(contents)) ;
        if (Int.equal (curr.(contents)) n) then
          cont ctx
        else ()
    )
.

Local Ltac reduce_free_evar_subst_step_2 star :=
      lazymatch goal with
      | [ |- context ctx [?p^[[evar: star ↦ ?q]] ] ]
        =>
          progress rewrite -> (@free_evar_subst_no_occurrence _ star p q) by (
            subst star;
            eapply evar_is_fresh_in_richer';
            [|apply set_evar_fresh_is_fresh'];
            simpl; clear; set_solver
          )
      end.

Local Ltac reduce_free_evar_subst_2 star :=
  (* unfold free_evar_subst; *)
  repeat (reduce_free_evar_subst_step_2 star).

Local Tactic Notation "solve_fresh_contradictions_2'" constr(star) constr(x) constr(h) :=
  let hcontra := fresh "Hcontra" in
  assert (hcontra: x <> star) by (subst star; unfold fresh_evar,evar_fresh_s; try clear h; simpl; solve_fresh_neq);
  rewrite -> h in hcontra;
  contradiction.

Local Ltac solve_fresh_contradictions_2 star :=
  unfold fresh_evar; simpl;
  match goal with
  | h: ?x = star |- _ =>
    let hprime := fresh "hprime" in
    pose proof (hprime := eq_sym h);
    solve_fresh_contradictions_2' star x hprime
  | h: star = ?x |- _
    => solve_fresh_contradictions_2' star x h
  end.

Local Ltac clear_obvious_equalities_2 :=
  repeat (
      match goal with
      | [ h: ?x = ?x |- _ ] => clear h
      end
    ).


Ltac simplify_emplace_2 star :=
  unfold emplace;
  (* unfold free_evar_subst; *)
  cbn;
  repeat break_match_goal;
  clear_obvious_equalities_2; try contradiction;
  try (solve_fresh_contradictions_2 star);
  (* repeat (rewrite nest_ex_aux_0); *)
  reduce_free_evar_subst_2 star.

(* Returns [n]th matching logic context [C] (of type [PatternCtx]) such that
   [emplace C a = phi].
 *)

 
 (* Ltac simplify_pile_side_condition_helper star :=
  subst star;
  unfold fresh_evar,evar_fresh_s;
  eapply evar_is_fresh_in_richer';
  [|apply set_evar_fresh_is_fresh'];
  clear; simpl; set_solver. *)

Ltac rewrite_0_depths star :=
  unfold mu_in_evar_path; cbn;
  repeat rewrite (maximal_exists_depth_to_0 star);
  repeat rewrite (maximal_mu_depth_to_0 star);
  repeat match goal with
  | [ |- context ctx [decide (star = star)] ] =>
    destruct (decide (star = star)); try congruence
  | [ |- context ctx [decide (?x = star)] ] =>
    destruct (decide (x = star)); try congruence
  | [ |- context ctx [decide (star = ?x)] ] =>
    destruct (decide (star = x)); try congruence
  | _ => idtac
  end;
  cbn.

Ltac try_solve_complex_pile star :=
  try apply pile_any;
  simplify_emplace_2 star;
  (rewrite_0_depths star);
  match goal with
  | |- star ∉ free_evars _ => subst star; solve_fresh
  | |- ProofInfoLe _ _ => try_solve_pile
  end.

Ltac2 Type HeatResult := {
  star_ident : ident ;
  star_eq : ident ;
  pc : constr ;
  ctx : Pattern.context ;
  ctx_pat : constr ;
  equality : ident ;
}.

(** NOTE: with the new MLGoal_rewriteIff, we also need the variables
          used in the list of hypotheses (l) for the fresh name
          generation.
*)
Ltac2 heat :=
  fun (n : int) (a : constr) (phi : constr) : HeatResult =>
    let found : (Pattern.context option) ref := { contents := None } in
     for_nth_match n a phi
     (fun ctx =>
        found.(contents) := Some ctx; ()
     );
     match found.(contents) with
    | None => Control.backtrack_tactic_failure "Cannot heat"
    | Some ctx
      => (
         let fr := constr:(fresh_evar $phi) in
         let star_ident := Fresh.in_goal ident:(star) in
         let star_eq := Fresh.in_goal ident:(star_eq) in
         (*set ($star_ident := $fr);*)
         remember $fr as $star_ident eqn:star_eq;
         let star_hyp := Control.hyp star_ident in
         let ctxpat := Pattern.instantiate ctx constr:(patt_free_evar $star_hyp) in
         let pc := constr:((@Build_PatternCtx _ $star_hyp $ctxpat)) in
         let heq1 := Fresh.in_goal ident:(heq1) in
         assert(heq1 : ($phi = (@emplace _ $pc $a))) 
         > [ abstract(
             (ltac1:(star |- simplify_emplace_2 star) (Ltac1.of_ident star_ident);
             reflexivity
             ))
           | ()
           ];
          { star_ident := star_ident; star_eq := star_eq; pc := pc; ctx := ctx; ctx_pat := ctxpat; equality := heq1 }
         )
    end
.

Ltac2 mlRewrite (hiff : constr) (atn : int) :=
  let thiff := Constr.type hiff in
  (* we have to unfold [derives] otherwise this might not match *)
  lazy_match! (eval unfold ProofSystem.derives in $thiff) with
  | _ ⊢i (?a <---> ?a') using _
    =>
    unfold AnyReasoning;
    lazy_match! goal with
    | [ |- of_MLGoal (@mkMLGoal ?sgm ?g ?l ?p ( ?gpi))]
      =>
        let hr : HeatResult := heat atn a p in
        if ml_debug_rewrite then
           Message.print (Message.of_constr (hr.(ctx_pat)))
         else () ;
         let heq := Control.hyp (hr.(equality)) in
         let pc := (hr.(pc)) in
         eapply (@cast_proof_ml_goal _ $g) >
           [ rewrite $heq; reflexivity | ()];
         Std.clear [hr.(equality)];
         let wfC := Fresh.in_goal ident:(wfC) in
         assert (wfC : PC_wf $pc = true) > [ ltac1:(unfold PC_wf; simpl; wf_auto2); Control.shelve () | ()] ;
         let wfCpf := Control.hyp wfC in
         apply (@MLGoal_rewriteIff $sgm $g _ _ $pc $l $gpi $wfCpf $hiff)  >
         [
         (lazy_match! goal with
         | [ |- of_MLGoal (@mkMLGoal ?sgm ?g ?l ?p _)]
           =>
             let heq2 := Fresh.in_goal ident:(heq2) in
             let plugged := Pattern.instantiate (hr.(ctx)) a' in
             assert(heq2: ($p = $plugged))
             > [
                 abstract (ltac1:(star |- simplify_emplace_2 star) (Ltac1.of_ident (hr.(star_ident)));
                 reflexivity
                 )
               | ()
               ];
             let heq2_pf := Control.hyp heq2 in
             eapply (@cast_proof_ml_goal _ $g) >
               [ rewrite $heq2_pf; reflexivity | ()];
             Std.clear [wfC; heq2 ; (hr.(star_ident)); (hr.(star_eq))]
         end)
         | (ltac1:(star |- try_solve_complex_pile star) (Ltac1.of_ident (hr.(star_ident))))
         ]
    end
  end.

Ltac2 rec constr_to_int (x : constr) : int :=
  match! x with
  | 0 => 0
  | (S ?x') => Int.add 1 (constr_to_int x')
  end.


Tactic Notation "mlRewrite" constr(Hiff) "at" constr(atn) :=
  _ensureProofMode;
  (let ff := ltac2:(hiff atn |-
                      mlRewrite
                        (Option.get (Ltac1.to_constr(hiff)))
                        (constr_to_int (Option.get (Ltac1.to_constr(atn))))
                   ) in
   ff Hiff atn);
   fold AnyReasoning.

Lemma pf_iff_equiv_sym_nowf {Σ : Signature} Γ A B i :
  Γ ⊢i (A <---> B) using i ->
  Γ ⊢i (B <---> A) using i.
Σ: Signature
Γ: Theory
A, B: Pattern
i: ProofInfo
Γ ⊢i A <---> B using i → Γ ⊢i B <---> A using i
Proof.
Σ: Signature
Γ: Theory
A, B: Pattern
i: ProofInfo
Γ ⊢i A <---> B using i → Γ ⊢i B <---> A using i
  intros H.
Σ: Signature
Γ: Theory
A, B: Pattern
i: ProofInfo
H: Γ ⊢i A <---> B using i
Γ ⊢i B <---> A using i
  pose proof (wfp := proved_impl_wf _ _ (proj1_sig H)).
Σ: Signature
Γ: Theory
A, B: Pattern
i: ProofInfo
H: Γ ⊢i A <---> B using i
wfp: well_formed (A <---> B)
Γ ⊢i B <---> A using i
  assert (well_formed A) by wf_auto2.
Σ: Signature
Γ: Theory
A, B: Pattern
i: ProofInfo
H: Γ ⊢i A <---> B using i
wfp: well_formed (A <---> B)
H0: well_formed A
Γ ⊢i B <---> A using i
  assert (well_formed B) by wf_auto2.
Σ: Signature
Γ: Theory
A, B: Pattern
i: ProofInfo
H: Γ ⊢i A <---> B using i
wfp: well_formed (A <---> B)
H0: well_formed A
H1: well_formed B
Γ ⊢i B <---> A using i
  apply pf_iff_equiv_sym; assumption.
Defined.

Tactic Notation "mlRewrite" "->" constr(Hiff) "at" constr(atn) :=
  mlRewrite Hiff at atn.

Tactic Notation "mlRewrite" "<-" constr(Hiff) "at" constr(atn) :=
  mlRewrite (@pf_iff_equiv_sym_nowf _ _ _ _ _ Hiff) at atn.


Local Example ex_prf_rewrite_equiv_2 {Σ : Signature} Γ a a' b x:
  well_formed a ->
  well_formed a' ->
  well_formed b ->
  Γ ⊢ a <---> a' ->
  Γ ⊢i (a $ a $ b $ a ---> (patt_free_evar x)) <---> (a $ a' $ b $ a' ---> (patt_free_evar x))
  using AnyReasoning.
Σ: Signature
Γ: Theory
a, a', b: Pattern
x: evar
well_formed a
→ well_formed a'
  → well_formed b
    → Γ ⊢ a <---> a'
      → Γ
        ⊢i (a $ a $ b $ a ---> patt_free_evar x) <--->
           (a $ a' $ b $ a' ---> patt_free_evar x)
        using AnyReasoning
Proof.
Σ: Signature
Γ: Theory
a, a', b: Pattern
x: evar
well_formed a
→ well_formed a'
  → well_formed b
    → Γ ⊢ a <---> a'
      → Γ
        ⊢i (a $ a $ b $ a ---> patt_free_evar x) <--->
           (a $ a' $ b $ a' ---> patt_free_evar x)
        using AnyReasoning
  intros wfa wfa' wfb Hiff.
Σ: Signature
Γ: Theory
a, a', b: Pattern
x: evar
wfa: well_formed a
wfa': well_formed a'
wfb: well_formed b
Hiff: Γ ⊢ a <---> a'
Γ
⊢i (a $ a $ b $ a ---> patt_free_evar x) <--->
   (a $ a' $ b $ a' ---> patt_free_evar x)
using AnyReasoning
  toMLGoal.
Σ: Signature
Γ: Theory
a, a', b: Pattern
x: evar
wfa: well_formed a
wfa': well_formed a'
wfb: well_formed b
Hiff: Γ ⊢ a <---> a'
well_formed
  ((a $ a $ b $ a ---> patt_free_evar x) <--->
   (a $ a' $ b $ a' ---> patt_free_evar x))
Σ: Signature
Γ: Theory
a, a', b: Pattern
x: evar
wfa: well_formed a
wfa': well_formed a'
wfb: well_formed b
Hiff: Γ ⊢ a <---> a'
Γ Ⱶ
 (a $ a $ b $ a ---> patt_free_evar x) <--->
 (a $ a' $ b $ a' ---> patt_free_evar x)

  {
Σ: Signature
Γ: Theory
a, a', b: Pattern
x: evar
wfa: well_formed a
wfa': well_formed a'
wfb: well_formed b
Hiff: Γ ⊢ a <---> a'
well_formed
  ((a $ a $ b $ a ---> patt_free_evar x) <--->
   (a $ a' $ b $ a' ---> patt_free_evar x)) abstract(wf_auto2). }
Σ: Signature
Γ: Theory
a, a', b: Pattern
x: evar
wfa: well_formed a
wfa': well_formed a'
wfb: well_formed b
Hiff: Γ ⊢ a <---> a'
Γ Ⱶ
 (a $ a $ b $ a ---> patt_free_evar x) <--->
 (a $ a' $ b $ a' ---> patt_free_evar x)

  mlRewrite Hiff at 2.
Σ: Signature
Γ: Theory
a, a', b: Pattern
x: evar
wfa: well_formed a
wfa': well_formed a'
wfb: well_formed b
Hiff: Γ ⊢ a <---> a'
Γ Ⱶ
 (a $ a' $ b $ a ---> patt_free_evar x) <--->
 (a $ a' $ b $ a' ---> patt_free_evar x)

  mlRewrite <- Hiff at 3.
Σ: Signature
Γ: Theory
a, a', b: Pattern
x: evar
wfa: well_formed a
wfa': well_formed a'
wfb: well_formed b
Hiff: Γ ⊢ a <---> a'
Γ Ⱶ
 (a $ a' $ b $ a ---> patt_free_evar x) <--->
 (a $ a' $ b $ a ---> patt_free_evar x)

  fromMLGoal.
Σ: Signature
Γ: Theory
a, a', b: Pattern
x: evar
wfa: well_formed a
wfa': well_formed a'
wfb: well_formed b
Hiff: Γ ⊢ a <---> a'
Γ
⊢i (a $ a' $ b $ a ---> patt_free_evar x) <--->
   (a $ a' $ b $ a ---> patt_free_evar x)
using AnyReasoning
  useBasicReasoning.
Σ: Signature
Γ: Theory
a, a', b: Pattern
x: evar
wfa: well_formed a
wfa': well_formed a'
wfb: well_formed b
Hiff: Γ ⊢ a <---> a'
Γ
⊢i (a $ a' $ b $ a ---> patt_free_evar x) <--->
   (a $ a' $ b $ a ---> patt_free_evar x)
using BasicReasoning
  apply pf_iff_equiv_refl.
Σ: Signature
Γ: Theory
a, a', b: Pattern
x: evar
wfa: well_formed a
wfa': well_formed a'
wfb: well_formed b
Hiff: Γ ⊢ a <---> a'
well_formed (a $ a' $ b $ a ---> patt_free_evar x) abstract(wf_auto2).
Defined.



(* TODO: de-duplicate the code *)
#[local]
Ltac convertToNNF_rewrite_pat Ctx p i :=
  lazymatch p with
    | (! ! ?x) =>
        let H' := fresh "H" in
        pose proof (@not_not_eq _ Ctx x ltac:(wf_auto2)) as H';
        apply (@useBasicReasoning _ _ _ i) in H';
        repeat (mlRewrite H' at 1);
        try clear H';
        convertToNNF_rewrite_pat Ctx x i
    | patt_not (patt_and ?x ?y) =>
        let H' := fresh "H" in
        pose proof (@deMorgan_nand _ Ctx x y ltac:(wf_auto2) ltac:(wf_auto2)) as H';
        apply (@useBasicReasoning _ _ _ i) in H';
        repeat (mlRewrite H' at 1);
        try clear H';
        convertToNNF_rewrite_pat Ctx (!x or !y) i
    | patt_not (patt_or ?x ?y) =>
        let H' := fresh "H" in
        pose proof (@deMorgan_nor _ Ctx x y ltac:(wf_auto2) ltac:(wf_auto2)) as H';
        apply (@useBasicReasoning _ _ _ i) in H';
        repeat (mlRewrite H' at 1);
        try clear H';
        convertToNNF_rewrite_pat Ctx (!x and !y) i
    | patt_not (?x ---> ?y) =>
        let H' := fresh "H" in
        pose proof (@nimpl_eq_and _ Ctx x y ltac:(wf_auto2) ltac:(wf_auto2)) as H';
        apply (@useBasicReasoning _ _ _ i) in H';
        repeat (mlRewrite H' at 1);
        try clear H';
        convertToNNF_rewrite_pat Ctx (x and !y) i
    | (?x ---> ?y) =>
        let H' := fresh "H" in
        pose proof (@impl_eq_or _ Ctx x y ltac:(wf_auto2) ltac:(wf_auto2)) as H';
        apply (@useBasicReasoning _ _ _ i) in H';
        repeat (mlRewrite H' at 1);
        try clear H';
        convertToNNF_rewrite_pat Ctx (!x or y) i
    | patt_and ?x ?y => convertToNNF_rewrite_pat Ctx x i; convertToNNF_rewrite_pat Ctx y i
    | patt_or ?x ?y => convertToNNF_rewrite_pat Ctx x i; convertToNNF_rewrite_pat Ctx y i
    | _ => idtac
  end.

#[local]
Ltac toNNF := 
  repeat mlRevertLast;
  match goal with
    | [ |- @of_MLGoal ?Sgm (@mkMLGoal ?Sgm ?Ctx ?ll ?g ?i) ] 
      =>
        mlApplyMetaRaw (@useBasicReasoning _ _ _ i (@not_not_elim Sgm Ctx g ltac:(wf_auto2)));
        convertToNNF_rewrite_pat Ctx (!g) i
  end.

#[local] Example test_toNNF {Σ : Signature} Γ a b :
  well_formed a ->
  well_formed b ->
  Γ ⊢i ( (b and (a or b) and !b and ( a or a) and a) ---> ⊥)
  using BasicReasoning.
Σ: Signature
Γ: Theory
a, b: Pattern
well_formed a
→ well_formed b
  → Γ
    ⊢i b and (a or b) and ! b and (a or a) and a --->
       ⊥ using BasicReasoning
Proof.
Σ: Signature
Γ: Theory
a, b: Pattern
well_formed a
→ well_formed b
  → Γ
    ⊢i b and (a or b) and ! b and (a or a) and a --->
       ⊥ using BasicReasoning
  intros wfa wfb.
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b
Γ ⊢i b and (a or b) and ! b and (a or a) and a ---> ⊥
using BasicReasoning
  toMLGoal.
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b
well_formed
  (b and (a or b) and ! b and (a or a) and a ---> ⊥)
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b
Γ Ⱶ
b and (a or b) and ! b and (a or a) and a ---> ⊥
using BasicReasoning

  {
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b
well_formed
  (b and (a or b) and ! b and (a or a) and a ---> ⊥) wf_auto2. }
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b
Γ Ⱶ
b and (a or b) and ! b and (a or a) and a ---> ⊥
using BasicReasoning

  toNNF.
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b
Γ Ⱶ
! (b and (a or b) and ! b and (a or a) and a and ! ⊥)
using BasicReasoning

Abort.

#[local]
Ltac rfindContradictionTo a ll k :=
  match ll with
    | ((mkNH _ ?name (! a)) :: ?m) =>
        mlApply name; mlExactn k
    | ((mkNH _ _ _) :: ?m) => 
        rfindContradictionTo a m k
    | _ => fail
  end.

#[local]
Ltac findContradiction l k:=
    match l with
       | ((mkNH _ _ ?a) :: ?m) => 
             match goal with
                | [ |- @of_MLGoal ?Sgm (@mkMLGoal ?Sgm ?Ctx ?ll ?g ?i) ] 
                  =>
                     try rfindContradictionTo a ll k;
                     let kk := eval compute in ( k + 1 ) in
                     (findContradiction m kk)
             end
       | _ => fail
    end.

#[local]
Ltac findContradiction_start :=
  match goal with
    | [ |- @of_MLGoal ?Sgm (@mkMLGoal ?Sgm ?Ctx ?l ?g ?i) ] 
      =>
        match goal with
          | [ |- @of_MLGoal ?Sgm (@mkMLGoal ?Sgm ?Ctx ?l ?g ?i) ] 
            =>
              findContradiction l 0
        end
  end.

#[local]
Ltac breakHyps l :=
  match l with
  | ((mkNH _ ?name (?x and ?y)) :: ?m) => 
      mlDestructAnd name
  | ((mkNH _ ?name (?x or ?y)) :: ?m) => 
      mlDestructOr name
  | ((mkNH _ ?name ?x) :: ?m)  =>
      breakHyps m
  end.

#[local]
Ltac mlTautoBreak := repeat match goal with
| [ |- @of_MLGoal ?Sgm (@mkMLGoal ?Sgm ?Ctx ?l ?g ?i) ] 
  =>
    lazymatch g with
      | (⊥) =>
              breakHyps l
      | _ => mlApplyMetaRaw (@useBasicReasoning _ _ _ i (@bot_elim _ _ g _))
    end
end.

Ltac try_solve_pile2 fallthrough :=
  lazymatch goal with
  | [ |- ProofInfoLe _ _] => try apply pile_refl; try_solve_pile; fallthrough
  | _ => idtac
  end.

#[global]
Ltac mlTauto :=
  _ensureProofMode;
  unshelve(
    try (
      toNNF; (try_solve_pile2 shelve);
      repeat mlIntro;
      mlTautoBreak;
      findContradiction_start
    )
  )
.

#[local]
Example conj_right {Σ : Signature} Γ a b:
  well_formed a ->
  well_formed b ->
  Γ ⊢i ( (b and (a or b) and !b and ( a or a) and a) ---> ⊥)
  using AnyReasoning.
Σ: Signature
Γ: Theory
a, b: Pattern
well_formed a
→ well_formed b
  → Γ
    ⊢i b and (a or b) and ! b and (a or a) and a --->
       ⊥ using AnyReasoning
Proof.
Σ: Signature
Γ: Theory
a, b: Pattern
well_formed a
→ well_formed b
  → Γ
    ⊢i b and (a or b) and ! b and (a or a) and a --->
       ⊥ using AnyReasoning
  intros wfa wfb.
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b
Γ ⊢i b and (a or b) and ! b and (a or a) and a ---> ⊥
using AnyReasoning
  toMLGoal.
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b
well_formed
  (b and (a or b) and ! b and (a or a) and a ---> ⊥)
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b
Γ Ⱶ
 b and (a or b) and ! b and (a or a) and a ---> ⊥

  {
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b
well_formed
  (b and (a or b) and ! b and (a or a) and a ---> ⊥) wf_auto2. }
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b
Γ Ⱶ
 b and (a or b) and ! b and (a or a) and a ---> ⊥

  (* TODO: fail loudly if there is something else than AnyReasoning *)
  mlTauto.
Defined.

#[local]
Example condtradict_taut_2 {Σ : Signature} Γ a b:
  well_formed a ->
  well_formed b ->
  Γ ⊢i (a ---> ((! a) ---> b))
  using AnyReasoning.
Σ: Signature
Γ: Theory
a, b: Pattern
well_formed a
→ well_formed b
  → Γ ⊢i a ---> ! a ---> b using AnyReasoning
Proof.
Σ: Signature
Γ: Theory
a, b: Pattern
well_formed a
→ well_formed b
  → Γ ⊢i a ---> ! a ---> b using AnyReasoning
  intros wfa wfb.
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b
Γ ⊢i a ---> ! a ---> b using AnyReasoning
  toMLGoal.
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b
well_formed (a ---> ! a ---> b)
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b
Γ Ⱶ
 a ---> ! a ---> b

  {
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b
well_formed (a ---> ! a ---> b) wf_auto2. }
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b
Γ Ⱶ
 a ---> ! a ---> b

  mlTauto.
Defined.

#[local]
Example taut {Σ : Signature} Γ a b c:
  well_formed a ->
  well_formed b ->
  well_formed c ->
  Γ ⊢i ((a ---> b) ---> ((b ---> c) ---> ((a or b)---> c)))
  using AnyReasoning.
Σ: Signature
Γ: Theory
a, b, c: Pattern
well_formed a
→ well_formed b
  → well_formed c
    → Γ
      ⊢i (a ---> b) ---> (b ---> c) ---> a or b ---> c
      using AnyReasoning
Proof.
Σ: Signature
Γ: Theory
a, b, c: Pattern
well_formed a
→ well_formed b
  → well_formed c
    → Γ
      ⊢i (a ---> b) ---> (b ---> c) ---> a or b ---> c
      using AnyReasoning
  intros wfa wfb wfc.
Σ: Signature
Γ: Theory
a, b, c: Pattern
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
Γ ⊢i (a ---> b) ---> (b ---> c) ---> a or b ---> c
using AnyReasoning
  toMLGoal.
Σ: Signature
Γ: Theory
a, b, c: Pattern
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
well_formed
  ((a ---> b) ---> (b ---> c) ---> a or b ---> c)
Σ: Signature
Γ: Theory
a, b, c: Pattern
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
Γ Ⱶ
 (a ---> b) ---> (b ---> c) ---> a or b ---> c

  {
Σ: Signature
Γ: Theory
a, b, c: Pattern
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
well_formed
  ((a ---> b) ---> (b ---> c) ---> a or b ---> c) wf_auto2. }
Σ: Signature
Γ: Theory
a, b, c: Pattern
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
Γ Ⱶ
 (a ---> b) ---> (b ---> c) ---> a or b ---> c

  mlTauto. (* Slow *)
Defined.

#[local]
Example condtradict_taut_1 {Σ : Signature} Γ a:
  well_formed a ->
  Γ ⊢i !(a and !a)
  using AnyReasoning.
Σ: Signature
Γ: Theory
a: Pattern
well_formed a → Γ ⊢i ! (a and ! a) using AnyReasoning
Proof.
Σ: Signature
Γ: Theory
a: Pattern
well_formed a → Γ ⊢i ! (a and ! a) using AnyReasoning
  intros wfa.
Σ: Signature
Γ: Theory
a: Pattern
wfa: well_formed a
Γ ⊢i ! (a and ! a) using AnyReasoning
  toMLGoal.
Σ: Signature
Γ: Theory
a: Pattern
wfa: well_formed a
well_formed (! (a and ! a))
Σ: Signature
Γ: Theory
a: Pattern
wfa: well_formed a
Γ Ⱶ
 ! (a and ! a)

  {
Σ: Signature
Γ: Theory
a: Pattern
wfa: well_formed a
well_formed (! (a and ! a)) wf_auto2. }
Σ: Signature
Γ: Theory
a: Pattern
wfa: well_formed a
Γ Ⱶ
 ! (a and ! a)

  mlTauto.
Defined.

#[local]
Example notnot_taut_1 {Σ : Signature} Γ a:
  well_formed a ->
  Γ ⊢i (! ! a ---> a)
  using AnyReasoning.
Σ: Signature
Γ: Theory
a: Pattern
well_formed a → Γ ⊢i ! ! a ---> a using AnyReasoning
Proof.
Σ: Signature
Γ: Theory
a: Pattern
well_formed a → Γ ⊢i ! ! a ---> a using AnyReasoning
  intros wfa.
Σ: Signature
Γ: Theory
a: Pattern
wfa: well_formed a
Γ ⊢i ! ! a ---> a using AnyReasoning
  toMLGoal.
Σ: Signature
Γ: Theory
a: Pattern
wfa: well_formed a
well_formed (! ! a ---> a)
Σ: Signature
Γ: Theory
a: Pattern
wfa: well_formed a
Γ Ⱶ
 ! ! a ---> a

  {
Σ: Signature
Γ: Theory
a: Pattern
wfa: well_formed a
well_formed (! ! a ---> a) wf_auto2. }
Σ: Signature
Γ: Theory
a: Pattern
wfa: well_formed a
Γ Ⱶ
 ! ! a ---> a

  mlTauto.
Defined.

#[local]
Lemma Peirce_taut {Σ : Signature} Γ a b:
  well_formed a ->
  well_formed b ->
  Γ ⊢i ((((a ---> b) ---> a) ---> a))
  using AnyReasoning.
Σ: Signature
Γ: Theory
a, b: Pattern
well_formed a
→ well_formed b
  → Γ ⊢i ((a ---> b) ---> a) ---> a using AnyReasoning
Proof.
Σ: Signature
Γ: Theory
a, b: Pattern
well_formed a
→ well_formed b
  → Γ ⊢i ((a ---> b) ---> a) ---> a using AnyReasoning
  intros wfa wfb.
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b
Γ ⊢i ((a ---> b) ---> a) ---> a using AnyReasoning
  toMLGoal.
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b
well_formed (((a ---> b) ---> a) ---> a)
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b
Γ Ⱶ
 ((a ---> b) ---> a) ---> a

  {
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b
well_formed (((a ---> b) ---> a) ---> a) wf_auto2. }
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b
Γ Ⱶ
 ((a ---> b) ---> a) ---> a

  mlTauto.
Defined.



Close Scope ml_scope.
Close Scope list_scope.
Close Scope string_scope.